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

plug-ins: refactor file-gegl so it can handle multiple file types 

and add support for NEF (Nikon RAW format). Also cleanup everything a
bit.
This commit is contained in:
Michael Natterer 2012-10-29 23:40:11 +01:00
parent 7f92d087bb
commit 569e42d79c
1 changed files with 198 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

304
plug-ins/common/file-gegl.c
View File

@ -30,23 +30,74 @@
#include "libgimp/stdplugins-intl.h" #include "libgimp/stdplugins-intl.h"
#define LOAD_PROC "file-gegl-load"
#define SAVE_PROC "file-gegl-save"
#define PLUG_IN_BINARY "file-gegl" #define PLUG_IN_BINARY "file-gegl"
static void query (void); typedef struct _FileFormat FileFormat;
static void run (const gchar *name,
gint nparams, struct _FileFormat
const GimpParam *param, {
gint *nreturn_vals, const gchar *file_type;
GimpParam **return_vals); const gchar *mime_type;
static gint32 load_image (const gchar *filename, const gchar *extensions;
GError **error); const gchar *magic;
static gboolean save_image (const gchar *filename,
gint32 image_ID, const gchar *load_proc;
gint32 drawable_ID, const gchar *load_blurb;
GError **error); const gchar *load_help;
const gchar *save_proc;
const gchar *save_blurb;
const gchar *save_help;
};
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static gint32 load_image (const gchar *filename,
GError **error);
static gboolean save_image (const gchar *filename,
gint32 image_ID,
gint32 drawable_ID,
GError **error);
static const FileFormat file_formats[] =
{
{
N_("EXR image"),
"image/x-exr",
"exr,hdr",
"",
"file-exr-load",
"Loads EXR images using GEGL",
"This procedure loads images in EXR format, using gegl:load",
"file-exr-save",
"Save EXR images using GEGL",
"This procedure saves images in EXR format, using gegl:save"
},
{
N_("NEF image"),
"image/x-nikon-nef",
"nef",
"",
"file-nef-load",
"Loads NEF images using GEGL",
"This procedure loads images in NEF format, using gegl:load",
NULL, NULL, NULL /* no NEF saving */
}
};
const GimpPlugInInfo PLUG_IN_INFO = const GimpPlugInInfo PLUG_IN_INFO =
{ {
@ -56,7 +107,6 @@ const GimpPlugInInfo PLUG_IN_INFO =
run, /* run_proc */ run, /* run_proc */
}; };
MAIN () MAIN ()
static void static void
@ -83,37 +133,52 @@ query (void)
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" } { GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" }
}; };
gimp_install_procedure (LOAD_PROC, gint i;
"Loads images using GEGL.",
"The GEGL image loader.",
"Simon Budig",
"Simon Budig",
"2012",
N_("image via GEGL"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
#warning need some EXR magic here. for (i = 0; i < G_N_ELEMENTS (file_formats); i++)
gimp_register_file_handler_mime (LOAD_PROC, "image/x-exr"); {
gimp_register_magic_load_handler (LOAD_PROC, "exr,hdr", "", ""); const FileFormat *format = &file_formats[i];
gimp_install_procedure (SAVE_PROC, gimp_install_procedure (format->load_proc,
"Saves images using GEGL.", format->load_blurb,
"The GEGL image saver", format->load_help,
"Simon Budig", "Simon Budig",
"Simon Budig", "Simon Budig",
"2012", "2012",
N_("image via GEGL"), format->file_type,
"RGB*, GRAY*, INDEXED*", NULL,
GIMP_PLUGIN, GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0, G_N_ELEMENTS (load_args),
save_args, NULL); G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_save_handler (SAVE_PROC, "exr,hdr", ""); gimp_register_file_handler_mime (format->load_proc,
format->mime_type);
gimp_register_magic_load_handler (format->load_proc,
format->extensions,
"",
format->magic);
if (format->save_proc)
{
gimp_install_procedure (format->save_proc,
format->save_blurb,
format->save_help,
"Simon Budig",
"Simon Budig",
"2012",
format->file_type,
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (format->save_proc,
format->mime_type);
gimp_register_save_handler (format->save_proc,
format->extensions, "");
}
}
} }
static void static void
@ -129,6 +194,7 @@ run (const gchar *name,
gint image_ID; gint image_ID;
gint drawable_ID; gint drawable_ID;
GError *error = NULL; GError *error = NULL;
gint i;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
@ -142,63 +208,73 @@ run (const gchar *name,
values[0].type = GIMP_PDB_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0) for (i = 0; i < G_N_ELEMENTS (file_formats); i++)
{ {
image_ID = load_image (param[1].data.d_string, &error); const FileFormat *format = &file_formats[i];
if (image_ID != -1) if (strcmp (name, format->load_proc))
{ {
*nreturn_vals = 2; image_ID = load_image (param[1].data.d_string, &error);
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; if (image_ID != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
break;
} }
else else if (strcmp (name, format->save_proc))
{ {
status = GIMP_PDB_EXECUTION_ERROR; GimpExportReturn export = GIMP_EXPORT_CANCEL;
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, NULL,
(GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_ALPHA));
if (export == GIMP_EXPORT_CANCEL)
{
*nreturn_vals = 1;
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
if (! save_image (param[3].data.d_string, image_ID, drawable_ID,
&error))
{
status = GIMP_PDB_EXECUTION_ERROR;
}
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image_ID);
break;
} }
} }
else if (strcmp (name, SAVE_PROC) == 0)
{
GimpExportReturn export = GIMP_EXPORT_CANCEL;
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */ if (i == G_N_ELEMENTS (file_formats))
switch (run_mode) status = GIMP_PDB_CALLING_ERROR;
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, NULL,
(GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_ALPHA));
if (export == GIMP_EXPORT_CANCEL)
{
*nreturn_vals = 1;
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
if (! save_image (param[3].data.d_string, image_ID, drawable_ID, &error))
{
status = GIMP_PDB_EXECUTION_ERROR;
}
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image_ID);
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status != GIMP_PDB_SUCCESS && error) if (status != GIMP_PDB_SUCCESS && error)
{ {
@ -223,30 +299,37 @@ load_image (const gchar *filename,
GimpPrecision precision; GimpPrecision precision;
gint width; gint width;
gint height; gint height;
GeglNode *graph, *sink, *source; GeglNode *graph;
GeglBuffer *src_buf = NULL, *dest_buf = NULL; GeglNode *sink;
const Babl *format, *model, *type; GeglNode *source;
GeglBuffer *src_buf = NULL;
GeglBuffer *dest_buf = NULL;
const Babl *format;
const Babl *model;
const Babl *type;
gimp_progress_init_printf (_("Opening '%s'"), gimp_progress_init_printf (_("Opening '%s'"),
gimp_filename_to_utf8 (filename)); gimp_filename_to_utf8 (filename));
graph = gegl_node_new (); graph = gegl_node_new ();
sink = gegl_node_new_child (graph,
"operation", "gegl:buffer-sink",
"buffer", &src_buf,
NULL);
source = gegl_node_new_child (graph, source = gegl_node_new_child (graph,
"operation", "gegl:load", "operation", "gegl:load",
"path", filename, "path", filename,
NULL); NULL);
sink = gegl_node_new_child (graph,
"operation", "gegl:buffer-sink",
"buffer", &src_buf,
NULL);
gegl_node_connect_to (source, "output", gegl_node_connect_to (source, "output",
sink, "input"); sink, "input");
gegl_node_process (sink); gegl_node_process (sink);
g_object_unref (graph); g_object_unref (graph);
if (!src_buf) if (! src_buf)
{ {
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Could not open '%s'"), _("Could not open '%s'"),
@ -254,9 +337,9 @@ load_image (const gchar *filename,
return -1; return -1;
} }
gimp_progress_update (80); gimp_progress_update (0.33);
width = gegl_buffer_get_width (src_buf); width = gegl_buffer_get_width (src_buf);
height = gegl_buffer_get_height (src_buf); height = gegl_buffer_get_height (src_buf);
format = gegl_buffer_get_format (src_buf); format = gegl_buffer_get_format (src_buf);
@ -268,6 +351,7 @@ load_image (const gchar *filename,
model == babl_model ("Y'A")) model == babl_model ("Y'A"))
{ {
base_type = GIMP_GRAY; base_type = GIMP_GRAY;
if (babl_format_has_alpha (format)) if (babl_format_has_alpha (format))
image_type = GIMP_GRAYA_IMAGE; image_type = GIMP_GRAYA_IMAGE;
else else
@ -276,6 +360,7 @@ load_image (const gchar *filename,
else if (babl_format_is_palette (format)) else if (babl_format_is_palette (format))
{ {
base_type = GIMP_INDEXED; base_type = GIMP_INDEXED;
if (babl_format_has_alpha (format)) if (babl_format_has_alpha (format))
image_type = GIMP_INDEXEDA_IMAGE; image_type = GIMP_INDEXEDA_IMAGE;
else else
@ -284,6 +369,7 @@ load_image (const gchar *filename,
else else
{ {
base_type = GIMP_RGB; base_type = GIMP_RGB;
if (babl_format_has_alpha (format)) if (babl_format_has_alpha (format))
image_type = GIMP_RGBA_IMAGE; image_type = GIMP_RGBA_IMAGE;
else else
@ -314,12 +400,14 @@ load_image (const gchar *filename,
gimp_image_insert_layer (image_ID, layer_ID, -1, 0); gimp_image_insert_layer (image_ID, layer_ID, -1, 0);
dest_buf = gimp_drawable_get_buffer (layer_ID); dest_buf = gimp_drawable_get_buffer (layer_ID);
gimp_progress_update (0.66);
gegl_buffer_copy (src_buf, NULL, dest_buf, NULL); gegl_buffer_copy (src_buf, NULL, dest_buf, NULL);
g_object_unref (src_buf); g_object_unref (src_buf);
g_object_unref (dest_buf); g_object_unref (dest_buf);
gimp_progress_update (100); gimp_progress_update (1.0);
return image_ID; return image_ID;
} }
@ -330,25 +418,29 @@ save_image (const gchar *filename,
gint32 drawable_ID, gint32 drawable_ID,
GError **error) GError **error)
{ {
GeglNode *graph, *sink, *source; GeglNode *graph;
GeglNode *source;
GeglNode *sink;
GeglBuffer *src_buf; GeglBuffer *src_buf;
src_buf = gimp_drawable_get_buffer (drawable_ID); src_buf = gimp_drawable_get_buffer (drawable_ID);
graph = gegl_node_new (); graph = gegl_node_new ();
source = gegl_node_new_child (graph, source = gegl_node_new_child (graph,
"operation", "gegl:buffer-source", "operation", "gegl:buffer-source",
"buffer", src_buf, "buffer", src_buf,
NULL); NULL);
sink = gegl_node_new_child (graph, sink = gegl_node_new_child (graph,
"operation", "gegl:save", "operation", "gegl:save",
"path", filename, "path", filename,
NULL); NULL);
gegl_node_connect_to (source, "output", gegl_node_connect_to (source, "output",
sink, "input"); sink, "input");
gegl_node_process (sink); gegl_node_process (sink);
g_object_unref (graph); g_object_unref (graph);
g_object_unref (src_buf); g_object_unref (src_buf);