dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/libgimp/gimpimagemetadata-save.c

1087 lines
38 KiB
C
Raw Normal View History

libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball
*
* gimpimagemetadata-save.c
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <sys/time.h>
#include <gexiv2/gexiv2.h>
#include "gimp.h"
#include "gimpimagemetadata.h"
#include "libgimp-intl.h"
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
static const gchar * gimp_fix_xmp_tag (const gchar *tag);
static void gimp_image_metadata_copy_tag (GExiv2Metadata *src,
GExiv2Metadata *dest,
const gchar *tag);
static gint gimp_natural_sort_compare (gconstpointer left,
gconstpointer right);
static GList* gimp_image_metadata_convert_tags_to_list (gchar **xmp_tags);
static gboolean gimp_image_metadata_get_xmp_struct_type (const gchar *tag,
GExiv2StructureType *struct_type);
static gboolean gimp_image_metadata_exclude_metadata (GList *exclude_list,
gchar *tag);
static GList* gimp_image_metadata_set_xmp_structs (GList *xmp_list,
GExiv2Metadata *metadata);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
/* public functions */
/**
* gimp_image_metadata_save_prepare:
libgimp: improve docs for gimp_image_metadata_save_prepare()/finish()
2019-10-10 06:05:49 +08:00
* @image: The original image
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
* @mime_type: The saved file's mime-type
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* @suggested_flags: Suggested default values for the metadata to export.
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* Gets the image metadata for storing it in an exported file.
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* *Note: There is normally no need to call this function because it's
* already called by [class@ExportProcedure] at the start and the
* metadata is passed to the `run()` callback.*
*
* *You may call it separately for instance if you set @export_metadata
* to %NULL in [ctor@Gimp.ExportProcedure.new] to prevent `libgimp`
* from trying to store the metadata in the exported file, yet you wish
* to process and store the metadata yourself using custom API.*
*
* The @suggested_flags are determined from what kind of metadata (Exif,
* XMP, ...) is actually present in the image and the preferences for
* metadata exporting.
* The calling application may still ignore @suggested_flags, for
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
* instance to follow the settings from a previous export in the same
* session, or a previous export of the same image. But it should not
* override the preferences without a good reason since it is a data
* leak.
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* The suggested value for [flags@Gimp.MetadataSaveFlags.THUMBNAIL] is
* determined by whether there was a thumbnail in the previously
* imported image.
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
*
* Returns: (transfer full): The image's metadata, prepared for saving.
*
* Since: 2.10
*/
GimpMetadata *
gimp_image_metadata_save_prepare (GimpImage *image,
const gchar *mime_type,
GimpMetadataSaveFlags *suggested_flags)
{
GimpMetadata *metadata;
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
GError *error = NULL;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (mime_type != NULL, NULL);
g_return_val_if_fail (suggested_flags != NULL, NULL);
*suggested_flags = GIMP_METADATA_SAVE_ALL;
metadata = gimp_image_get_metadata (image);
if (metadata)
{
libgimp, libgimpconfig: use gimp_parasite_get_data(). As previously do not trust that parasite contents is proper text ending with nul character by always using the parasite size info.
2021-01-30 15:57:43 +08:00
GDateTime *datetime;
GimpParasite *comment_parasite;
gchar *comment = NULL;
gint image_width;
gint image_height;
gdouble xres;
gdouble yres;
gchar buffer[32];
libgimp: fix #1632 GIMP should not write to IPTC tag DateCreated GIMP was saving the last changed/saved date to IPTC tag DateCreated, which should only be used for the original creating date of the image and thus should not be changed by GIMP. After discussion in the cited issue, there is no tag in IPTC that we can use, so we remove saving modified date from the IPTC metadata. Instead we add two XMP tags, one for modified date and the other for the date that metadata was changed. Since we do both when exporting, both are saved with the same date/time in ISO 8601 format. This also fixes another issue where we were not storing the timezone offset for Xmp.tiff.DateTime. Since this has the same format as the other XMP tags, we fix this together with this issue.
2022-06-07 07:03:03 +08:00
gchar *datetime_buf = NULL;
libgimp, libgimpconfig: use gimp_parasite_get_data(). As previously do not trust that parasite contents is proper text ending with nul character by always using the parasite size info.
2021-01-30 15:57:43 +08:00
GExiv2Metadata *g2metadata = GEXIV2_METADATA (metadata);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
app, libgimp, pdb, plug-ins: update some more functions to get|set(). s/gimp_image_base_type/gimp_image_get_base_type/ s/gimp_image_width/gimp_image_get_width/ s/gimp_image_height/gimp_image_get_height/ Sorry plug-in developers, more porting work! But really this seems like the right thing to do in order not to get stuck with inconsistent naming for many more years to come.
2021-04-06 06:47:07 +08:00
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
datetime = g_date_time_new_now_local ();
comment_parasite = gimp_image_get_parasite (image, "gimp-comment");
if (comment_parasite)
libgimp, libgimpconfig: use gimp_parasite_get_data(). As previously do not trust that parasite contents is proper text ending with nul character by always using the parasite size info.
2021-01-30 15:57:43 +08:00
{
guint32 parasite_size;
comment = (gchar *) gimp_parasite_get_data (comment_parasite, &parasite_size);
comment = g_strndup (comment, parasite_size);
gimp_parasite_free (comment_parasite);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
/* Exif */
if (! gimp_export_exif () ||
! gexiv2_metadata_has_exif (g2metadata))
*suggested_flags &= ~GIMP_METADATA_SAVE_EXIF;
if (comment)
{
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Exif.Photo.UserComment",
comment, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Photo.UserComment", error->message);
g_clear_error (&error);
}
gexiv2_metadata_try_set_tag_string (g2metadata,
"Exif.Image.ImageDescription",
comment, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Image.ImageDescription", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
g_snprintf (buffer, sizeof (buffer),
"%d:%02d:%02d %02d:%02d:%02d",
g_date_time_get_year (datetime),
g_date_time_get_month (datetime),
g_date_time_get_day_of_month (datetime),
g_date_time_get_hour (datetime),
g_date_time_get_minute (datetime),
g_date_time_get_second (datetime));
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Exif.Image.DateTime",
buffer, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Image.DateTime", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Exif.Image.Software",
PACKAGE_STRING, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Image.Software", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
gimp_metadata_set_pixel_size (metadata,
image_width, image_height);
gimp_image_get_resolution (image, &xres, &yres);
gimp_metadata_set_resolution (metadata, xres, yres,
gimp_image_get_unit (image));
/* XMP */
if (! gimp_export_xmp () ||
! gexiv2_metadata_has_xmp (g2metadata))
*suggested_flags &= ~GIMP_METADATA_SAVE_XMP;
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.dc.Format",
mime_type, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.dc.Format", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: fix #1632 GIMP should not write to IPTC tag DateCreated GIMP was saving the last changed/saved date to IPTC tag DateCreated, which should only be used for the original creating date of the image and thus should not be changed by GIMP. After discussion in the cited issue, there is no tag in IPTC that we can use, so we remove saving modified date from the IPTC metadata. Instead we add two XMP tags, one for modified date and the other for the date that metadata was changed. Since we do both when exporting, both are saved with the same date/time in ISO 8601 format. This also fixes another issue where we were not storing the timezone offset for Xmp.tiff.DateTime. Since this has the same format as the other XMP tags, we fix this together with this issue.
2022-06-07 07:03:03 +08:00
/* XMP uses datetime in ISO 8601 format */
datetime_buf = g_date_time_format (datetime, "%Y:%m:%dT%T\%:z");
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.xmp.ModifyDate",
datetime_buf, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.xmp.ModifyDate", error->message);
g_clear_error (&error);
}
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.xmp.MetadataDate",
datetime_buf, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.xmp.MetadataDate", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (! g_strcmp0 (mime_type, "image/tiff"))
{
/* TIFF specific XMP data */
g_snprintf (buffer, sizeof (buffer), "%d", image_width);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.tiff.ImageWidth",
buffer, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.tiff.ImageWidth", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_snprintf (buffer, sizeof (buffer), "%d", image_height);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.tiff.ImageLength",
buffer, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.tiff.ImageLength", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (g2metadata,
"Xmp.tiff.DateTime",
libgimp: fix #1632 GIMP should not write to IPTC tag DateCreated GIMP was saving the last changed/saved date to IPTC tag DateCreated, which should only be used for the original creating date of the image and thus should not be changed by GIMP. After discussion in the cited issue, there is no tag in IPTC that we can use, so we remove saving modified date from the IPTC metadata. Instead we add two XMP tags, one for modified date and the other for the date that metadata was changed. Since we do both when exporting, both are saved with the same date/time in ISO 8601 format. This also fixes another issue where we were not storing the timezone offset for Xmp.tiff.DateTime. Since this has the same format as the other XMP tags, we fix this together with this issue.
2022-06-07 07:03:03 +08:00
datetime_buf, &error);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.tiff.DateTime", error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
/* IPTC */
if (! gimp_export_iptc () ||
! gexiv2_metadata_has_iptc (g2metadata))
*suggested_flags &= ~GIMP_METADATA_SAVE_IPTC;
libgimp: fix #1632 GIMP should not write to IPTC tag DateCreated GIMP was saving the last changed/saved date to IPTC tag DateCreated, which should only be used for the original creating date of the image and thus should not be changed by GIMP. After discussion in the cited issue, there is no tag in IPTC that we can use, so we remove saving modified date from the IPTC metadata. Instead we add two XMP tags, one for modified date and the other for the date that metadata was changed. Since we do both when exporting, both are saved with the same date/time in ISO 8601 format. This also fixes another issue where we were not storing the timezone offset for Xmp.tiff.DateTime. Since this has the same format as the other XMP tags, we fix this together with this issue.
2022-06-07 07:03:03 +08:00
g_free (datetime_buf);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_date_time_unref (datetime);
libgimp, libgimpconfig: use gimp_parasite_get_data(). As previously do not trust that parasite contents is proper text ending with nul character by always using the parasite size info.
2021-01-30 15:57:43 +08:00
g_clear_pointer (&comment, g_free);
plug-ins: fix #7613 overwrite export creates thumbnail when it shouldn't When overwriting the same file when exporting, we didn't check if the image previously had a thumbnail. If the default setting in Preferences is to add a thumbnail, then it would add one where it shouldn't. Since thumbnails get saves as part of the EXIF metadata, we need to check that to see if there was a thumbnail in the original image. However, we were always removing the thumbnail from the metadata on import. Let's delay removing this metadata until we need to, which has the advantage that the metadata in our viewer is more complete. When exporting starts, we add a check in gimp_image_metadata_save_prepare to see if there was a thumbnail in the EXIF metadata. If not, then we disable the thumbnail flag. In gimp_image_metadata_save_filter we remove the thumbnail metadata when the user doesn't want to save a thumbnail, or when the image format does not support EXIF.
2022-05-23 02:00:36 +08:00
/* EXIF Thumbnail */
if (gimp_export_thumbnail () && gexiv2_metadata_has_exif (g2metadata))
{
gchar *value;
/* Check a required tag for a thumbnail to be present. */
value = gexiv2_metadata_try_get_tag_string (g2metadata,
"Exif.Thumbnail.ImageLength",
NULL);
if (! value)
{
*suggested_flags &= ~GIMP_METADATA_SAVE_THUMBNAIL;
}
else
{
g_free (value);
}
}
else
{
*suggested_flags &= ~GIMP_METADATA_SAVE_THUMBNAIL;
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
else
{
/* At least initialize the returned flags with preferences defaults */
if (! gimp_export_exif ())
*suggested_flags &= ~GIMP_METADATA_SAVE_EXIF;
if (! gimp_export_xmp ())
*suggested_flags &= ~GIMP_METADATA_SAVE_XMP;
if (! gimp_export_iptc ())
*suggested_flags &= ~GIMP_METADATA_SAVE_IPTC;
plug-ins: fix #7613 overwrite export creates thumbnail when it shouldn't When overwriting the same file when exporting, we didn't check if the image previously had a thumbnail. If the default setting in Preferences is to add a thumbnail, then it would add one where it shouldn't. Since thumbnails get saves as part of the EXIF metadata, we need to check that to see if there was a thumbnail in the original image. However, we were always removing the thumbnail from the metadata on import. Let's delay removing this metadata until we need to, which has the advantage that the metadata in our viewer is more complete. When exporting starts, we add a check in gimp_image_metadata_save_prepare to see if there was a thumbnail in the EXIF metadata. If not, then we disable the thumbnail flag. In gimp_image_metadata_save_filter we remove the thumbnail metadata when the user doesn't want to save a thumbnail, or when the image format does not support EXIF.
2022-05-23 02:00:36 +08:00
if (! gimp_export_thumbnail ())
*suggested_flags &= ~GIMP_METADATA_SAVE_THUMBNAIL;
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
/* Color profile */
if (! gimp_export_color_profile ())
*suggested_flags &= ~GIMP_METADATA_SAVE_COLOR_PROFILE;
libgimp: manage boolean "save-comment" properties automatically using the GimpProcedureConfig/GimpMetadata mechanism.
2019-10-10 07:30:29 +08:00
/* Comment */
if (! gimp_export_comment ())
*suggested_flags &= ~GIMP_METADATA_SAVE_COMMENT;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
return metadata;
}
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
static const gchar *
gimp_fix_xmp_tag (const gchar *tag)
{
gchar *substring;
/* Due to problems using /Iptc4xmpExt namespace (/iptcExt is used
* instead by Exiv2) we replace all occurrences with /iptcExt which
* is valid but less common. Not doing so would cause saving xmp
* metadata to fail. This has to be done after getting the values
* from the source metadata since that source uses the original
* tag names and would otherwise return NULL as value.
* /Iptc4xmpExt length = 12
* /iptcExt length = 8
*/
substring = strstr (tag, "/Iptc4xmpExt");
while (substring)
{
gint len_tag = strlen (tag);
gint len_end;
len_end = len_tag - (substring - tag) - 12;
strncpy (substring, "/iptcExt", 8);
substring += 8;
/* Using memmove: we have overlapping source and dest */
memmove (substring, substring+4, len_end);
substring[len_end] = '\0';
g_debug ("Fixed tag value: %s", tag);
/* Multiple occurrences are possible: e.g.:
* Xmp.iptcExt.ImageRegion[3]/Iptc4xmpExt:RegionBoundary/Iptc4xmpExt:rbVertices[1]/Iptc4xmpExt:rbX
*/
substring = strstr (tag, "/Iptc4xmpExt");
}
return tag;
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
static void
gimp_image_metadata_copy_tag (GExiv2Metadata *src,
GExiv2Metadata *dest,
const gchar *tag)
{
libgimp: more un-deprecating GExiv2. Last deprecated usages in this file. Actually there are a few other calls but deprecated on GExiv2 0.14.0, hence over our current requirement. So we'll have to handle these later.
2022-01-21 01:43:36 +08:00
gchar **values = gexiv2_metadata_try_get_tag_multiple (src, tag, NULL);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
GError *error = NULL;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (values)
{
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
gchar *temp_tag;
/* Xmp always seems to return multiple values */
if (g_str_has_prefix (tag, "Xmp."))
temp_tag = (gchar *) gimp_fix_xmp_tag (g_strdup (tag));
else
temp_tag = g_strdup (tag);
g_debug ("Copy multi tag %s, first value: %s", temp_tag, values[0]);
libgimp: more un-deprecating GExiv2. Last deprecated usages in this file. Actually there are a few other calls but deprecated on GExiv2 0.14.0, hence over our current requirement. So we'll have to handle these later.
2022-01-21 01:43:36 +08:00
gexiv2_metadata_try_set_tag_multiple (dest, temp_tag,
(const gchar **) values,
&error);
if (error)
{
g_warning ("%s: failed to set multiple metadata '%s': %s\n",
G_STRFUNC, tag, error->message);
g_clear_error (&error);
}
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
g_free (temp_tag);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_strfreev (values);
}
else
{
libgimp: more un-deprecating GExiv2. Last deprecated usages in this file. Actually there are a few other calls but deprecated on GExiv2 0.14.0, hence over our current requirement. So we'll have to handle these later.
2022-01-21 01:43:36 +08:00
gchar *value = gexiv2_metadata_try_get_tag_string (src, tag, &error);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (value)
{
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
g_debug ("Copy tag %s, value: %s", tag, value);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (dest, tag, value, &error);
if (error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, tag, error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_free (value);
}
libgimp: more un-deprecating GExiv2. Last deprecated usages in this file. Actually there are a few other calls but deprecated on GExiv2 0.14.0, hence over our current requirement. So we'll have to handle these later.
2022-01-21 01:43:36 +08:00
else if (error)
{
g_warning ("%s: failed to get metadata '%s': %s\n",
G_STRFUNC, tag, error->message);
g_clear_error (&error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
}
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
static gint
gimp_natural_sort_compare (gconstpointer left,
gconstpointer right)
{
gint compare;
gchar *left_key = g_utf8_collate_key_for_filename ((gchar *) left, -1);
gchar *right_key = g_utf8_collate_key_for_filename ((gchar *) right, -1);
compare = g_strcmp0 (left_key, right_key);
g_free (left_key);
g_free (right_key);
return compare;
}
static GList*
gimp_image_metadata_convert_tags_to_list (gchar **xmp_tags)
{
GList *list = NULL;
gint i;
for (i = 0; xmp_tags[i] != NULL; i++)
{
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
g_debug ("Tag: %s, tag type: %s", xmp_tags[i], gexiv2_metadata_try_get_tag_type (xmp_tags[i], NULL));
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
list = g_list_prepend (list, xmp_tags[i]);
}
return list;
}
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
static gboolean
gimp_image_metadata_get_xmp_struct_type (const gchar *tag,
GExiv2StructureType *struct_type)
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
{
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
GError *error = NULL;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
g_debug ("Struct type for tag: %s, type: %s", tag, gexiv2_metadata_try_get_tag_type (tag, NULL));
if (! g_strcmp0 (gexiv2_metadata_try_get_tag_type (tag, &error), "XmpSeq"))
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
{
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
*struct_type = GEXIV2_STRUCTURE_XA_SEQ;
return TRUE;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
}
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
if (error)
{
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
g_debug ("%s: failed to get type of tag '%s': %s\n",
G_STRFUNC, tag, error->message);
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
g_clear_error (&error);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
*struct_type = GEXIV2_STRUCTURE_XA_NONE;
return FALSE;
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
}
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
*struct_type = GEXIV2_STRUCTURE_XA_BAG;
return TRUE;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
}
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
static gboolean
gimp_image_metadata_exclude_metadata (GList *exclude_list,
gchar *tag)
{
GList *list;
for (list = exclude_list; list != NULL; list = list->next)
{
if (strstr (tag, (gchar *) list->data))
{
return TRUE;
}
}
return FALSE;
}
static GList*
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
gimp_image_metadata_set_xmp_structs (GList *xmp_list,
GExiv2Metadata *metadata)
{
GList *list;
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
GList *exclude = NULL;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
gchar *prev_one = NULL;
gchar *prev_two = NULL;
for (list = xmp_list; list != NULL; list = list->next)
{
gchar **tag_split;
/*
* Most tags with structs have only one struct part, like:
* Xmp.xmpMM.History[1]...
* However there are also Xmp tags that have two
* structs in one tag, e.g.:
* Xmp.crs.GradientBasedCorrections[1]/crs:CorrectionMasks[1]...
*/
tag_split = g_strsplit ((gchar *) list->data, "[1]", 3);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
/* Check if there are at least two parts */
if (tag_split && tag_split[1])
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
{
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
GError *error = NULL;
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
if (strstr (tag_split[0], "["))
{
gchar **splits = NULL;
gint last_part = -1;
/* Handle things like:
* Xmp.iptcExt.ImageRegion[3]/Iptc4xmpExt:RegionBoundary/Iptc4xmpExt:rbVertices[1]/Iptc4xmpExt:rbX,
* where rbVertices only appears in ImageRegion[3].
* We only want the part starting with the last '/'.
*/
splits = g_strsplit (tag_split[0], "/", 0);
if (splits)
{
GExiv2StructureType type;
gchar *tag_inner = NULL;
for (int i = 0; splits[i] != NULL; i++)
{
last_part = i;
}
tag_inner = g_strconcat ("/", splits[last_part], NULL);
if (gimp_image_metadata_get_xmp_struct_type (gimp_fix_xmp_tag (tag_inner), &type))
{
gexiv2_metadata_try_set_xmp_tag_struct (GEXIV2_METADATA (metadata),
tag_inner, type, &error);
if (error)
{
g_printerr ("%s: failed to set XMP struct '%s': %s\n",
G_STRFUNC, tag_inner, error->message);
g_clear_error (&error);
}
}
else
{
/* Add to exclude list */
if (! g_list_find_custom (exclude, tag_inner, (GCompareFunc) g_strcmp0))
{
g_debug ("Adding unsupported tag to exclude list: %s", tag_inner);
exclude = g_list_prepend (exclude, g_strdup (tag_inner));
}
}
g_free (tag_inner);
}
g_strfreev (splits);
}
else if (! prev_one || strcmp (tag_split[0], prev_one) != 0)
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
{
GExiv2StructureType type;
g_free (prev_one);
prev_one = g_strdup (tag_split[0]);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
if (gimp_image_metadata_get_xmp_struct_type (gimp_fix_xmp_tag (tag_split[0]), &type))
{
gexiv2_metadata_try_set_xmp_tag_struct (GEXIV2_METADATA (metadata),
prev_one, type, &error);
if (error)
{
g_printerr ("%s: failed to set XMP struct '%s': %s\n",
G_STRFUNC, prev_one, error->message);
g_clear_error (&error);
}
}
else
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
{
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
/* Add to exclude list */
if (! g_list_find_custom (exclude, tag_split[0], (GCompareFunc) g_strcmp0))
{
g_debug ("Adding unsupported tag to exclude list: %s", tag_split[0]);
exclude = g_list_prepend (exclude, g_strdup (tag_split[0]));
}
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
}
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
}
if (tag_split[2] && (!prev_two || strcmp (tag_split[1], prev_two) != 0))
{
gchar *second_struct;
GExiv2StructureType type;
g_free (prev_two);
prev_two = g_strdup (tag_split[1]);
second_struct = g_strdup_printf ("%s[1]%s", prev_one, gimp_fix_xmp_tag(prev_two));
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
if (gimp_image_metadata_get_xmp_struct_type (gimp_fix_xmp_tag (tag_split[1]), &type))
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
{
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
gexiv2_metadata_try_set_xmp_tag_struct (GEXIV2_METADATA (metadata),
second_struct, type, &error);
if (error)
{
g_printerr ("%s: failed to set XMP struct '%s': %s\n",
G_STRFUNC, second_struct, error->message);
g_clear_error (&error);
}
}
else
{
/* Add to exclude list */
if (! g_list_find_custom (exclude, tag_split[1], (GCompareFunc) g_strcmp0))
{
g_debug ("Adding unsupported tag to exclude list: %s", tag_split[1]);
exclude = g_list_prepend (exclude, g_strdup (tag_split[1]));
}
libgimp: undeprecate some more GExiv2 calls. Replace functions gexiv2_metadata_set_xmp_tag_struct() and gexiv2_metadata_get_tag_type() with their _try_ variants. Note that I print to stderr rather than raising a warning here as I am quite unsure where the list of XMP metadata we are gathering comes from. Is it fully validated by GExiv2, and therefore no errors are ever supposed to happen? (in such case, we should raise a warning if it does) Or is it user-provided data (e.g. from a file loaded in GIMP which can contain broken metadata)? In such a case, we should probably handle the error slightly differently to warn for non-processable data (hence possibly metadata loss at export time). For the time being, then go with this weak handling and take care of this better when we can look further into this.
2022-01-21 01:26:07 +08:00
}
libgimp: fix resource leak in gimpimagemetadata-save
2023-07-11 00:45:43 +08:00
g_free (second_struct);
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
}
}
g_strfreev (tag_split);
}
g_free (prev_one);
g_free (prev_two);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
return exclude;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
/**
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* gimp_image_metadata_save_filter:
libgimp: improve docs for gimp_image_metadata_save_prepare()/finish()
2019-10-10 06:05:49 +08:00
* @image: The actually saved image
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
* @mime_type: The saved file's mime-type
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* @metadata: The metadata to export
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
* @flags: Flags to specify what of the metadata to save
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* @file: The file @image was saved to or NULL if file was not saved yet
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
* @error: Return location for error message
*
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* Filters the @metadata retrieved from the image with
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* [method@Gimp.Image.metadata_save_prepare], taking into account the
* passed @flags.
*
* *Note: There is normally no need to call this function because it's
* already called by [class@ExportProcedure] after the `run()`
* callback.*
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
*
libgimp: improve docs for gimp_image_metadata_save_prepare()/finish()
2019-10-10 06:05:49 +08:00
* Note that the @image passed to this function might be different
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* from the image passed to `gimp_image_metadata_save_prepare()`, due
libgimp: improve docs for gimp_image_metadata_save_prepare()/finish()
2019-10-10 06:05:49 +08:00
* to whatever file export conversion happened in the meantime
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* This can be used as an alternative to core metadata handling when you
* want to save metadata yourself and you need only filtering
* processing.
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* Returns: (transfer full): Filtered metadata or %NULL in case of failure.
* Use [GObject.Object.unref] when returned metadata are no
* longer needed
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
*
* Since: 3.0
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
*/
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
GimpMetadata *
gimp_image_metadata_save_filter (GimpImage *image,
const gchar *mime_type,
GimpMetadata *metadata,
GimpMetadataSaveFlags flags,
GFile *file,
GError **error)
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
{
GimpMetadata *new_metadata;
GExiv2Metadata *new_g2metadata;
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
/* Error for cases where we have full control, such as metadata tags
* and contents. So we don't propagate these in @error (for things out
* of our control, such as read or write errors), but we use them as
* internal warning for bugs.
*/
GError *code_error = NULL;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
gboolean support_exif;
gboolean support_xmp;
gboolean support_iptc;
gint i;
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (mime_type != NULL, NULL);
g_return_val_if_fail (GEXIV2_IS_METADATA (metadata), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (! (flags & (GIMP_METADATA_SAVE_EXIF |
GIMP_METADATA_SAVE_XMP |
GIMP_METADATA_SAVE_IPTC |
GIMP_METADATA_SAVE_THUMBNAIL)))
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
return NULL;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
if (file)
{
/* read metadata from saved file */
new_metadata = gimp_metadata_load_from_file (file, error);
}
else
{
new_metadata = gimp_metadata_new ();
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (! new_metadata)
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
return NULL;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
new_g2metadata = GEXIV2_METADATA (new_metadata);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
support_exif = gexiv2_metadata_get_supports_exif (new_g2metadata);
support_xmp = gexiv2_metadata_get_supports_xmp (new_g2metadata);
support_iptc = gexiv2_metadata_get_supports_iptc (new_g2metadata);
if ((flags & GIMP_METADATA_SAVE_EXIF) && support_exif)
{
gchar **exif_data = gexiv2_metadata_get_exif_tags (GEXIV2_METADATA (metadata));
for (i = 0; exif_data[i] != NULL; i++)
{
libgimp: replace deprecated functions ... 1. gexiv2_metadata_has_tag with gexiv2_metadata_try_has_tag; 2. gexiv2_metadata_set_exif_thumbnail_from_buffer with the "try" version. For a while now the minimum gexiv2 version for the master branch is 0.14.0, which means we can replace these deprecated functions, since the new versions were added in 0.14.0.
2023-05-19 03:23:59 +08:00
if (! gexiv2_metadata_try_has_tag (new_g2metadata, exif_data[i], NULL) &&
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
gimp_metadata_is_tag_supported (exif_data[i], mime_type))
{
gimp_image_metadata_copy_tag (GEXIV2_METADATA (metadata),
new_g2metadata,
exif_data[i]);
}
}
g_strfreev (exif_data);
}
if ((flags & GIMP_METADATA_SAVE_XMP) && support_xmp)
{
gchar **xmp_data;
struct timeval timer_usec;
gint64 timestamp_usec;
gchar ts[128];
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
GList *xmp_list = NULL;
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
GList *exclude_list = NULL;
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
GList *list;
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
gettimeofday (&timer_usec, NULL);
timestamp_usec = ((gint64) timer_usec.tv_sec) * 1000000ll +
(gint64) timer_usec.tv_usec;
g_snprintf (ts, sizeof (ts), "%" G_GINT64_FORMAT, timestamp_usec);
gimp_metadata_add_xmp_history (metadata, "");
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (GEXIV2_METADATA (metadata),
"Xmp.GIMP.TimeStamp",
ts, &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.GIMP.TimeStamp", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (GEXIV2_METADATA (metadata),
"Xmp.xmp.CreatorTool",
N_("GIMP"), &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.xmp.CreatorTool", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (GEXIV2_METADATA (metadata),
"Xmp.GIMP.Version",
GIMP_VERSION, &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.GIMP.Version", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (GEXIV2_METADATA (metadata),
"Xmp.GIMP.API",
GIMP_API_VERSION, &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.GIMP.API", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (GEXIV2_METADATA (metadata),
"Xmp.GIMP.Platform",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
"Windows",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#elif defined(__linux__)
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
"Linux",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#elif defined(__APPLE__) && defined(__MACH__)
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
"Mac OS",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#elif defined(unix) || defined(__unix__) || defined(__unix)
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
"Unix",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#else
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
"Unknown",
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
#endif
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
&code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Xmp.GIMP.Platform", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
xmp_data = gexiv2_metadata_get_xmp_tags (GEXIV2_METADATA (metadata));
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
xmp_list = gimp_image_metadata_convert_tags_to_list (xmp_data);
xmp_list = g_list_sort (xmp_list, (GCompareFunc) gimp_natural_sort_compare);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
exclude_list = gimp_image_metadata_set_xmp_structs (xmp_list, new_g2metadata);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
for (list = xmp_list; list != NULL; list = list->next)
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
{
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
gchar *fixed = NULL;
/* Certain XMP metadata tags currently can't be saved by us until
* we get support in gexiv2 for adding new structs.
* We remove these from the exported metadata because the XMPSDK
* in exiv2 would otherwise fail to write all XMP metadata. */
fixed = (gchar *) gimp_fix_xmp_tag (g_strdup ((gchar *) list->data));
if (gimp_image_metadata_exclude_metadata (exclude_list, (gchar *) fixed))
{
g_warning ("Unsupported XMP metadata tag (not saved): %s", fixed);
}
else if (! gexiv2_metadata_try_has_tag (new_g2metadata, (gchar *) list->data, NULL) &&
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
gimp_metadata_is_tag_supported ((gchar *) list->data, mime_type))
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
{
gimp_image_metadata_copy_tag (GEXIV2_METADATA (metadata),
new_g2metadata,
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
(gchar *) list->data);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
else
g_debug ("Ignored tag: %s", (gchar *) list->data);
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
g_free (fixed);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
}
libgimp: fix failure to write XMP metadata Certain XMP metadata tags currently can't be saved by us until we get support in gexiv2 for adding new structs not present in exiv2. We remove these tags from the exported metadata because the XMPSDK in exiv2 would otherwise fail to write all XMP metadata. Examples are the newer (2019, 2021, 2022) sample images from the IPTC Photo Metadata Standard. We also add all the static functions present in gimpimagemetadata-save at the top, which had been forgotten in the past.
2023-05-21 00:14:29 +08:00
g_list_free_full (exclude_list, g_free);
libgimp: improve saving xmp metadata. 1. Convert xmp /Iptc4xmpExt tag parts to /iptcExt because exiv2 fails when we try to use the default namespace. 2. Don't only set structs from a fixed list but find all xmp array elements and check what the best struct type is: bag or seq. 3. Work around a sorting issue in (g)exiv2 by using a natural sorting algorithm ourselves. 4. Added some g_debug statements to make it easier to determine the cause of issues.
2021-03-22 01:04:30 +08:00
g_list_free (xmp_list);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_strfreev (xmp_data);
}
if ((flags & GIMP_METADATA_SAVE_IPTC) && support_iptc)
{
gchar **iptc_data = gexiv2_metadata_get_iptc_tags (GEXIV2_METADATA (metadata));
for (i = 0; iptc_data[i] != NULL; i++)
{
libgimp: replace deprecated functions ... 1. gexiv2_metadata_has_tag with gexiv2_metadata_try_has_tag; 2. gexiv2_metadata_set_exif_thumbnail_from_buffer with the "try" version. For a while now the minimum gexiv2 version for the master branch is 0.14.0, which means we can replace these deprecated functions, since the new versions were added in 0.14.0.
2023-05-19 03:23:59 +08:00
if (! gexiv2_metadata_try_has_tag (new_g2metadata, iptc_data[i], NULL) &&
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
gimp_metadata_is_tag_supported (iptc_data[i], mime_type))
{
gimp_image_metadata_copy_tag (GEXIV2_METADATA (metadata),
new_g2metadata,
iptc_data[i]);
}
}
g_strfreev (iptc_data);
}
plug-ins: fix #7613 overwrite export creates thumbnail when it shouldn't When overwriting the same file when exporting, we didn't check if the image previously had a thumbnail. If the default setting in Preferences is to add a thumbnail, then it would add one where it shouldn't. Since thumbnails get saves as part of the EXIF metadata, we need to check that to see if there was a thumbnail in the original image. However, we were always removing the thumbnail from the metadata on import. Let's delay removing this metadata until we need to, which has the advantage that the metadata in our viewer is more complete. When exporting starts, we add a check in gimp_image_metadata_save_prepare to see if there was a thumbnail in the EXIF metadata. If not, then we disable the thumbnail flag. In gimp_image_metadata_save_filter we remove the thumbnail metadata when the user doesn't want to save a thumbnail, or when the image format does not support EXIF.
2022-05-23 02:00:36 +08:00
if (flags & GIMP_METADATA_SAVE_THUMBNAIL && support_exif)
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
{
GdkPixbuf *thumb_pixbuf;
gchar *thumb_buffer;
gint image_width;
gint image_height;
gsize count;
gint thumbw;
gint thumbh;
#define EXIF_THUMBNAIL_SIZE 256
app, libgimp, pdb, plug-ins: update some more functions to get|set(). s/gimp_image_base_type/gimp_image_get_base_type/ s/gimp_image_width/gimp_image_get_width/ s/gimp_image_height/gimp_image_get_height/ Sorry plug-in developers, more porting work! But really this seems like the right thing to do in order not to get stuck with inconsistent naming for many more years to come.
2021-04-06 06:47:07 +08:00
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (image_width > image_height)
{
thumbw = EXIF_THUMBNAIL_SIZE;
thumbh = EXIF_THUMBNAIL_SIZE * image_height / image_width;
}
else
{
thumbh = EXIF_THUMBNAIL_SIZE;
thumbw = EXIF_THUMBNAIL_SIZE * image_width / image_height;
}
app, libgimp: core loads thumbnail from metadata if no GimpThumbnailProcedure… … is set. The order for thumbnail creation in gimp_imagefile_create_thumbnail() is now: 1. If there is a GimpThumbnailProcedure, it is run first. 2. Otherwise we check if a thumbnail is in the metadata. 3. As last resort, we just load the full image. Part of the fix was to copy gimp_image_metadata_load_thumbnail() into the core code. I have been wondering if we could not drop the same function from libgimp and remove the GimpThumbnailProcedure frome file-jpeg, since it just uses the metadata thumbnail and it is the only plug-in using this code. Also it is much faster to run this in core and it's generic function which makes thumbnail loading from Exif data working for every format supported by Exiv2. On the other hand, the file-jpeg thumbnail procedure also gathers a few more useful information, such as the color model (in a reliably manner, since based on JPEG header, unlike from metadata which may be wrong).
2023-08-12 04:55:50 +08:00
/* TODO: currently our exported thumbnails are always RGB because
* GdkPixbuf only supports RGB so far. While RGB thumbnail may make sense,
* even for CMYK images or other color spaces, grayscale images would be
* better served with a grayscale thumbnail too.
*/
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
thumb_pixbuf = gimp_image_get_thumbnail (image, thumbw, thumbh,
GIMP_PIXBUF_KEEP_ALPHA);
if (gdk_pixbuf_save_to_buffer (thumb_pixbuf, &thumb_buffer, &count,
"jpeg", NULL,
"quality", "75",
NULL))
{
gchar buffer[32];
libgimp: replace deprecated functions ... 1. gexiv2_metadata_has_tag with gexiv2_metadata_try_has_tag; 2. gexiv2_metadata_set_exif_thumbnail_from_buffer with the "try" version. For a while now the minimum gexiv2 version for the master branch is 0.14.0, which means we can replace these deprecated functions, since the new versions were added in 0.14.0.
2023-05-19 03:23:59 +08:00
gexiv2_metadata_try_set_exif_thumbnail_from_buffer (new_g2metadata,
(guchar *) thumb_buffer,
count, &code_error);
if (code_error)
{
g_warning ("%s: failed to set Exif thumbnail: %s\n",
G_STRFUNC, code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_snprintf (buffer, sizeof (buffer), "%d", thumbw);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.ImageWidth",
buffer, &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.ImageWidth", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_snprintf (buffer, sizeof (buffer), "%d", thumbh);
libgimp: port a bunch of gexiv2_metadata_set_tag_string() to … … gexiv2_metadata_try_set_tag_string(). These are usage where we have full control over tag names and values so no error is supposed to happen. This is why we use them as code warnings and not returned error (because if an error did happen, this would be a bug rather than a user error or a system error).
2022-01-21 00:56:28 +08:00
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.ImageLength",
buffer, &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.ImageLength", code_error->message);
g_clear_error (&code_error);
}
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.BitsPerSample",
"8 8 8", &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.BitsPerSample", code_error->message);
g_clear_error (&code_error);
}
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.SamplesPerPixel",
"3", &code_error);
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.SamplesPerPixel", code_error->message);
g_clear_error (&code_error);
}
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.PhotometricInterpretation",
"6", &code_error); /* old jpeg */
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.PhotometricInterpretation",
code_error->message);
g_clear_error (&code_error);
}
gexiv2_metadata_try_set_tag_string (new_g2metadata,
"Exif.Thumbnail.NewSubfileType",
"1", &code_error); /* reduced resolution image */
if (code_error)
{
g_warning ("%s: failed to set metadata '%s': %s\n",
G_STRFUNC, "Exif.Thumbnail.NewSubfileType", code_error->message);
g_clear_error (&code_error);
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
g_free (thumb_buffer);
}
g_object_unref (thumb_pixbuf);
}
plug-ins: fix #7613 overwrite export creates thumbnail when it shouldn't When overwriting the same file when exporting, we didn't check if the image previously had a thumbnail. If the default setting in Preferences is to add a thumbnail, then it would add one where it shouldn't. Since thumbnails get saves as part of the EXIF metadata, we need to check that to see if there was a thumbnail in the original image. However, we were always removing the thumbnail from the metadata on import. Let's delay removing this metadata until we need to, which has the advantage that the metadata in our viewer is more complete. When exporting starts, we add a check in gimp_image_metadata_save_prepare to see if there was a thumbnail in the EXIF metadata. If not, then we disable the thumbnail flag. In gimp_image_metadata_save_filter we remove the thumbnail metadata when the user doesn't want to save a thumbnail, or when the image format does not support EXIF.
2022-05-23 02:00:36 +08:00
else
{
/* Remove Thumbnail */
gexiv2_metadata_try_erase_exif_thumbnail (new_g2metadata, &code_error);
if (code_error)
{
g_warning ("%s: failed to erase EXIF thumbnail: %s\n",
G_STRFUNC, code_error->message);
g_clear_error (&code_error);
}
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
if (flags & GIMP_METADATA_SAVE_COLOR_PROFILE)
{
/* nothing to do, but if we ever need to modify metadata based
* on the exported color profile, this is probably the place to
* add it
*/
}
libgimp: manage boolean "save-comment" properties automatically using the GimpProcedureConfig/GimpMetadata mechanism.
2019-10-10 07:30:29 +08:00
if (flags & GIMP_METADATA_SAVE_COMMENT)
{
/* nothing to do, blah blah */
}
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
return new_metadata;
}
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
/* Internal functions */
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
/**
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* _gimp_image_metadata_save_finish:
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* @image: The actually saved image
* @mime_type: The saved file's mime-type
* @metadata: The metadata to write to @file
* @flags: Flags to specify what of the metadata to save
* @file: The file @image was saved to
* @error: Return location for error message
*
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* *Note: There is normally no need to call this function because it's
* already called by [class@ExportProcedure] at the end of the `run()` callback.*
*
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
* Saves the @metadata retrieved from the image with
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* [method@Gimp.Image.metadata_save_prepare] to @file, taking into
* account the passed @flags.
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
*
* Note that the @image passed to this function might be different
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
* from the image passed to `gimp_image_metadata_save_prepare()`, due to
* whatever file export conversion happened in the meantime
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
*
* Returns: Whether the save was successful.
*
* Since: 2.10
*/
gboolean
libgimp: clean up the GimpImage's metadata API. gimp_image_metadata_load_prepare(), gimp_image_metadata_load_finish() and gimp_image_metadata_save_finish() are only ever used internally now, so there is no need to expose them. If we realize that we need them as public functions later, or someone reports a valid use case, we can always bring them back later. Also improves a bit various annotations.
2024-09-28 20:49:41 +08:00
_gimp_image_metadata_save_finish (GimpImage *image,
const gchar *mime_type,
GimpMetadata *metadata,
GimpMetadataSaveFlags flags,
GFile *file,
GError **error)
libgimp: new gimp_image_metadata_save_filter API This new function is an alternative to existing gimp_image_metadata_save_finish, when you want to save metadata yourself and you need only filtering processing. It returns filtered metadata allowing the caller to save the finalized metadata via other means (via native format’s library for example) This API can be used to support metadata saving of image formats not directly supported by gexiv2/exiv2.
2022-03-15 20:01:45 +08:00
{
GimpMetadata *new_metadata;
gboolean success = FALSE;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (mime_type != NULL, FALSE);
g_return_val_if_fail (GEXIV2_IS_METADATA (metadata), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! (flags & (GIMP_METADATA_SAVE_EXIF |
GIMP_METADATA_SAVE_XMP |
GIMP_METADATA_SAVE_IPTC |
GIMP_METADATA_SAVE_THUMBNAIL)))
return TRUE;
new_metadata = gimp_image_metadata_save_filter (image, mime_type, metadata,
flags, file, error);
if (! new_metadata)
{
return FALSE;
}
libgimp: start integrating image export with GimpProcedureConfig Add gimp_procedure_config_begin_export() and end_export() which are wrappers around begin_run() and end_run() and additionally pretty much completely manage GimpMetadata handling. A GimpProcedureConfig can provide boolean properties "save-exif", "save-xmp" etc. in order to have them automatically managed by begin_export() and end_export(). This also restores the feature of overriding the procedure's saved default values with export preferences, but not the values from the last export, like it used to be in 2.10. Move gimp_image_metadata_save_prepare() and save_finish() (which are now completely handled by GimpProcedureConfig) from libgimpui to libgimp, but keep their declarations in the libgimpui header. Not perfect, but not finished either. Also fix gimp_image_metadata_save_prepare() to set the affected GimpMetadataSaveFlags to 0 when the image has no metadata at all.
2019-10-10 04:32:07 +08:00
success = gimp_metadata_save_to_file (new_metadata, file, error);
g_object_unref (new_metadata);
return success;
}