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

567 lines
21 KiB
C
Raw Blame History

/* metadata.c - main() for the metadata editor
*
* Copyright (C) 2004-2005, Raphaël Quinet <raphael@gimp.org>
*
* 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
* <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libexif/exif-data.h>
#include "libgimp/stdplugins-intl.h"
#include "metadata.h"
#include "xmp-schemas.h"
#include "xmp-encode.h"
#include "interface.h"
#include "exif-decode.h"
/* FIXME: uncomment when these are working
#include "exif-encode.h"
#include "iptc-decode.h"
*/
#define METADATA_PARASITE "gimp-metadata"
#define METADATA_MARKER "GIMP_XMP_1"
#define METADATA_MARKER_LEN (strlen (METADATA_MARKER))
/* prototypes of local functions */
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
/* local variables */
const GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
/* local functions */
MAIN ()
static void
query (void)
{
static const GimpParamDef editor_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" }
};
static const GimpParamDef decode_xmp_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "xmp", "XMP packet" }
};
static const GimpParamDef encode_xmp_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" }
};
static const GimpParamDef encode_xmp_return_vals[] =
{
{ GIMP_PDB_STRING, "xmp", "XMP packet" }
};
static const GimpParamDef decode_exif_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_INT32, "exif-size", "size of the EXIF block" },
{ GIMP_PDB_INT8ARRAY, "exif", "EXIF block" }
};
/* FIXME: uncomment when these are working
static const GimpParamDef encode_exif_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" }
};
static const GimpParamDef encode_exif_return_vals[] =
{
{ GIMP_PDB_INT32, "exif-size", "size of the EXIF block" },
{ GIMP_PDB_INT8ARRAY, "exif", "EXIF block" }
};
*/
static const GimpParamDef get_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" },
{ GIMP_PDB_STRING, "property", "XMP property name" }
};
static const GimpParamDef get_return_vals[] =
{
{ GIMP_PDB_INT32, "type", "XMP property type" },
{ GIMP_PDB_INT32, "num-vals", "number of values" },
{ GIMP_PDB_STRINGARRAY, "vals", "XMP property values" }
};
static const GimpParamDef set_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" },
{ GIMP_PDB_STRING, "property", "XMP property name" },
{ GIMP_PDB_INT32, "type", "XMP property type" },
{ GIMP_PDB_INT32, "num-vals", "number of values" },
{ GIMP_PDB_STRINGARRAY, "vals", "XMP property values" }
};
static const GimpParamDef get_simple_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" },
{ GIMP_PDB_STRING, "property", "XMP property name" }
};
static const GimpParamDef get_simple_return_vals[] =
{
{ GIMP_PDB_STRING, "value", "XMP property value" }
};
static const GimpParamDef set_simple_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" },
{ GIMP_PDB_STRING, "property", "XMP property name" },
{ GIMP_PDB_STRING, "value", "XMP property value" }
};
/* FIXME: uncomment when these are working
static const GimpParamDef delete_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" },
{ GIMP_PDB_STRING, "property", "XMP property name" }
};
static const GimpParamDef add_schema_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "prefix", "XMP schema prefix" },
{ GIMP_PDB_STRING, "uri", "XMP schema URI" }
};
*/
static const GimpParamDef import_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "filename", "The name of the XMP file to import" }
};
static const GimpParamDef export_args[] =
{
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the XMP packet in" },
{ GIMP_PDB_INT32, "overwrite", "Overwrite existing file: { FALSE (0), TRUE (1) }" }
};
gimp_install_procedure (EDITOR_PROC,
N_("View and edit metadata (EXIF, IPTC, XMP)"),
"View and edit metadata information attached to the "
"current image. This can include EXIF, IPTC and/or "
"XMP information. Some or all of this metadata "
"will be saved in the file, depending on the output "
"file format.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2004-2005",
N_("Propert_ies"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (editor_args), 0,
editor_args, NULL);
gimp_plugin_menu_register (EDITOR_PROC, "<Image>/File/Info");
// XXX gimp_plugin_icon_register (EDITOR_PROC, GIMP_ICON_TYPE_STOCK_ID,
gimp_install_procedure (DECODE_XMP_PROC,
"Decode an XMP packet",
"Parse an XMP packet and merge the results with "
"any metadata already attached to the image. This "
"should be used when an XMP packet is read from an "
"image file.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (decode_xmp_args), 0,
decode_xmp_args, NULL);
gimp_install_procedure (ENCODE_XMP_PROC,
"Encode metadata into an XMP packet",
"Generate an XMP packet from the metadata "
"information attached to the image. The new XMP "
"packet can then be saved into a file.",
"Róman Joost <romanofski@gimp.org>",
"Róman Joost <romanofski@gimp.org>",
"2008",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (encode_xmp_args),
G_N_ELEMENTS (encode_xmp_return_vals),
encode_xmp_args, encode_xmp_return_vals);
gimp_install_procedure (DECODE_EXIF_PROC,
"Decode an EXIF block",
"Parse an EXIF block and merge the results with "
"any metadata already attached to the image. This "
"should be used when an EXIF block is read from an "
"image file.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (decode_exif_args), 0,
decode_exif_args, NULL);
/* FIXME: uncomment when these are working
gimp_install_procedure (ENCODE_EXIF_PROC,
"Encode metadata into an EXIF block",
"Generate an EXIF block from the metadata "
"information attached to the image. The new EXIF "
"block can then be saved into a file.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (encode_exif_args),
G_N_ELEMENTS (encode_exif_return_vals),
encode_exif_args, encode_exif_return_vals);
*/
gimp_install_procedure (GET_PROC,
"Retrieve the values of an XMP property",
"Retrieve the list of values associated with "
"an XMP property.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (get_args),
G_N_ELEMENTS (get_return_vals),
get_args, get_return_vals);
gimp_install_procedure (SET_PROC,
"Set the values of an XMP property",
"Set the list of values associated with "
"an XMP property. If a property with the same "
"name already exists, it will be replaced.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (set_args), 0,
set_args, NULL);
gimp_install_procedure (GET_SIMPLE_PROC,
"Retrieve the value of an XMP property",
"Retrieve value associated with a scalar XMP "
"property. This can only be done for simple "
"property types such as text or integers. "
"Structured types must be retrieved with "
"plug_in_metadata_get().",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (get_simple_args),
G_N_ELEMENTS (get_simple_return_vals),
get_simple_args, get_simple_return_vals);
gimp_install_procedure (SET_SIMPLE_PROC,
"Set the value of an XMP property",
"Set the value of a scalar XMP property. This "
"can only be done for simple property types such "
"as text or integers. Structured types need to "
"be set with plug_in_metadata_set().",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (set_simple_args), 0,
set_simple_args, NULL);
gimp_install_procedure (IMPORT_PROC,
"Import XMP from a file into the current image",
"Load an XMP packet from a file and import it into "
"the current image. This can be used to add a "
"license statement or some other predefined "
"metadata to an image",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (import_args), 0,
import_args, NULL);
gimp_install_procedure (EXPORT_PROC,
"Export XMP from the current image to a file",
"Export the metadata associated with the current "
"image into a file. The metadata will be saved as "
"an XMP packet. If overwrite is TRUE, then any "
"existing file will be overwritten without warning. "
"If overwrite is FALSE, then an error will occur if "
"the file already exists.",
"Raphaël Quinet <raphael@gimp.org>",
"Raphaël Quinet <raphael@gimp.org>",
"2005",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (export_args), 0,
export_args, NULL);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[4];
gint32 image_ID;
XMPModel *xmp_model;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpParasite *parasite = NULL;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
INIT_I18N();
g_type_init();
if (! strcmp (name, EDITOR_PROC))
image_ID = param[1].data.d_image;
else
image_ID = param[0].data.d_image;
xmp_model = xmp_model_new ();
/* if there is already a metadata parasite, load it */
parasite = gimp_image_get_parasite (image_ID, METADATA_PARASITE);
if (parasite)
{
GError *error = NULL;
if (!! strncmp (gimp_parasite_data (parasite),
METADATA_MARKER, METADATA_MARKER_LEN)
|| ! xmp_model_parse_buffer (xmp_model,
(const gchar *) gimp_parasite_data (parasite)
+ METADATA_MARKER_LEN,
gimp_parasite_data_size (parasite)
- METADATA_MARKER_LEN,
TRUE, &error))
{
g_printerr ("\nMetadata parasite seems to be corrupt\n");
/* continue anyway, we will attach a clean parasite later */
}
gimp_parasite_free (parasite);
}
/* If we have no metadata yet, try to find an XMP packet in the file
* (but ignore errors if nothing is found).
*
* FIXME: This is a workaround until all file plug-ins do the right
* thing when loading their files.
*/
if (xmp_model_is_empty (xmp_model)
&& !! strcmp (name, DECODE_XMP_PROC))
{
const gchar *filename;
GError *error = NULL;
filename = gimp_image_get_filename (image_ID);
if (filename != NULL)
if (xmp_model_parse_file (xmp_model, filename, &error))
/* g_message ("XMP loaded from file '%s'\n", filename) */;
}
/* Now check what we are supposed to do */
if (! strcmp (name, DECODE_XMP_PROC))
{
const gchar *buffer;
GError *error = NULL;
buffer = param[1].data.d_string;
if (! xmp_model_parse_buffer (xmp_model, buffer, strlen (buffer),
FALSE, &error))
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, ENCODE_XMP_PROC))
{
/* done below together with the parasite */
}
else if (! strcmp (name, DECODE_EXIF_PROC))
{
GError *error = NULL;
if (! xmp_merge_from_exifbuffer (xmp_model, image_ID, &error))
{
status = GIMP_PDB_EXECUTION_ERROR;
g_printerr ("\nExif to XMP merge failed.\n");
}
}
else if (! strcmp (name, GET_PROC))
{
g_printerr ("Not implemented yet (GET_PROC)\n"); /* FIXME */
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, SET_PROC))
{
g_printerr ("Not implemented yet (SET_PROC)\n"); /* FIXME */
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, GET_SIMPLE_PROC))
{
const gchar *schema_name;
const gchar *property_name;
const gchar *value;
schema_name = param[1].data.d_string;
property_name = param[2].data.d_string;
value = xmp_model_get_scalar_property (xmp_model, schema_name,
property_name);
if (value)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = g_strdup (value);
}
else
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, SET_SIMPLE_PROC))
{
const gchar *schema_name;
const gchar *property_name;
const gchar *property_value;
schema_name = param[1].data.d_string;
property_name = param[2].data.d_string;
property_value = param[3].data.d_string;
if (! xmp_model_set_scalar_property (xmp_model, schema_name,
property_name, property_value))
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, IMPORT_PROC))
{
const gchar *filename;
gchar *buffer;
gsize buffer_length;
GError *error = NULL;
filename = param[1].data.d_string;
if (! g_file_get_contents (filename, &buffer, &buffer_length, &error))
{
g_error_free (error);
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! xmp_model_parse_buffer (xmp_model, buffer, buffer_length,
TRUE, &error))
{
g_error_free (error);
status = GIMP_PDB_EXECUTION_ERROR;
}
g_free (buffer);
}
else if (! strcmp (name, EXPORT_PROC))
{
/* FIXME: this is easy to implement, but the first thing to do is */
/* to improve the code of export_dialog_response() in interface.c */
g_printerr ("Not implemented yet (EXPORT_PROC)\n");
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (! strcmp (name, EDITOR_PROC))
{
GimpRunMode run_mode;
run_mode = param[0].data.d_int32;
if (run_mode == GIMP_RUN_INTERACTIVE)
{
if (! metadata_dialog (image_ID, xmp_model))
status = GIMP_PDB_CANCEL;
}
g_printerr ("Not implemented yet (EDITOR_PROC)\n");
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
GString *buffer;
/* Generate the updated parasite and attach it to the image */
buffer = g_string_new (METADATA_MARKER);
xmp_generate_packet (xmp_model, buffer);
parasite = gimp_parasite_new (METADATA_PARASITE,
GIMP_PARASITE_PERSISTENT,
buffer->len,
(gpointer) buffer->str);
gimp_image_attach_parasite (image_ID, parasite);
if (! strcmp (name, ENCODE_XMP_PROC))
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = g_strdup (buffer->str
+ METADATA_MARKER_LEN);
}
g_string_free (buffer, TRUE);
}
g_object_unref (xmp_model);
values[0].data.d_status = status;
}
Reference in New Issue View Git Blame Copy Permalink