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

Remove GimpUint8Array in favor of GBytes 

GLib has a specific type for byte arrays: `GBytes` (and it's underlying
GType `G_TYPE_BYTES`).

By using this type, we can avoid having a `GimpUint8Array` which is a
bit cumbersome to use for both the C API, as well as bindings. By using
`GBytes`, we allow other languages to pass on byte arrays as they are
used to, while the bindings will make sure to do the right thing.

In the end, it makes the API a little bit simpler for everyone, and
reduces confusion for people who are used to working with byte arrays
in other C/GLib based code (and not having 2 different types to denote
the same thing).

Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
This commit is contained in:
Niels De Graef 2023-05-23 23:37:46 +02:00
parent 9e79bb78a1
commit 89c359ce47
98 changed files with 841 additions and 1681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
app/core/gimp-memsize.c
View File

@ -220,7 +220,6 @@ gimp_g_value_get_memsize (GValue *value)
NULL);
}
else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
GIMP_VALUE_HOLDS_UINT8_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
{
@ -230,6 +229,15 @@ gimp_g_value_get_memsize (GValue *value)
memsize += sizeof (GimpArray) +
(array->static_data ? 0 : array->length);
}
else if (G_VALUE_HOLDS (value, G_TYPE_BYTES))
{
GBytes *bytes = g_value_get_boxed (value);
if (bytes)
{
memsize += g_bytes_get_size (bytes);
}
}
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
gchar **array = g_value_get_boxed (value);

50
app/pdb/brush-cmds.c
View File

@ -332,11 +332,9 @@ brush_get_pixels_invoker (GimpProcedure *procedure,
gint width = 0;
gint height = 0;
gint mask_bpp = 0;
gint num_mask_bytes = 0;
guint8 *mask_bytes = NULL;
GBytes *mask_bytes = NULL;
gint color_bpp = 0;
gint num_color_bytes = 0;
guint8 *color_bytes = NULL;
GBytes *color_bytes = NULL;
brush = g_value_get_object (gimp_value_array_index (args, 0));
@ -346,6 +344,8 @@ brush_get_pixels_invoker (GimpProcedure *procedure,
GimpTempBuf *pixmap = gimp_brush_get_pixmap (brush);
const Babl *format;
gpointer data;
gsize num_mask_bytes;
gsize num_color_bytes;
format = gimp_babl_compat_u8_mask_format (
gimp_temp_buf_get_format (mask));
@ -356,7 +356,7 @@ brush_get_pixels_invoker (GimpProcedure *procedure,
mask_bpp = babl_format_get_bytes_per_pixel (format);
num_mask_bytes = gimp_temp_buf_get_height (mask) *
gimp_temp_buf_get_width (mask) * mask_bpp;
mask_bytes = g_memdup2 (data, num_mask_bytes);
mask_bytes = g_bytes_new (data, num_mask_bytes);
gimp_temp_buf_unlock (mask, data);
@ -370,7 +370,7 @@ brush_get_pixels_invoker (GimpProcedure *procedure,
num_color_bytes = gimp_temp_buf_get_height (pixmap) *
gimp_temp_buf_get_width (pixmap) *
color_bpp;
color_bytes = g_memdup2 (data, num_color_bytes);
color_bytes = g_bytes_new (data, num_color_bytes);
gimp_temp_buf_unlock (pixmap, data);
}
@ -384,11 +384,9 @@ brush_get_pixels_invoker (GimpProcedure *procedure,
g_value_set_int (gimp_value_array_index (return_vals, 1), width);
g_value_set_int (gimp_value_array_index (return_vals, 2), height);
g_value_set_int (gimp_value_array_index (return_vals, 3), mask_bpp);
g_value_set_int (gimp_value_array_index (return_vals, 4), num_mask_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 5), mask_bytes, num_mask_bytes);
g_value_set_int (gimp_value_array_index (return_vals, 6), color_bpp);
g_value_set_int (gimp_value_array_index (return_vals, 7), num_color_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 8), color_bytes, num_color_bytes);
g_value_take_boxed (gimp_value_array_index (return_vals, 4), mask_bytes);
g_value_set_int (gimp_value_array_index (return_vals, 5), color_bpp);
g_value_take_boxed (gimp_value_array_index (return_vals, 6), color_bytes);
}
return return_vals;
@ -1186,16 +1184,11 @@ register_brush_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-mask-bytes",
"num mask bytes",
"Length of brush mask data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("mask-bytes",
"mask bytes",
"The brush mask data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("mask-bytes",
"mask bytes",
"The brush mask data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("color-bpp",
"color bpp",
@ -1203,16 +1196,11 @@ register_brush_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-color-bytes",
"num color bytes",
"Length of brush color data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("color-bytes",
"color bytes",
"The brush color data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("color-bytes",
"color bytes",
"The brush color data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

238
app/pdb/drawable-cmds.c
View File

@ -594,100 +594,6 @@ drawable_update_invoker (GimpProcedure *procedure,
error ? *error : NULL);
}
static GimpValueArray *
drawable_get_pixel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpDrawable *drawable;
gint x_coord;
gint y_coord;
gint num_channels = 0;
guint8 *pixel = NULL;
drawable = g_value_get_object (gimp_value_array_index (args, 0));
x_coord = g_value_get_int (gimp_value_array_index (args, 1));
y_coord = g_value_get_int (gimp_value_array_index (args, 2));
if (success)
{
const Babl *format = gimp_drawable_get_format (drawable);
if (x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
y_coord < gimp_item_get_height (GIMP_ITEM (drawable)))
{
num_channels = babl_format_get_bytes_per_pixel (format);
pixel = g_new0 (guint8, num_channels);
gegl_buffer_sample (gimp_drawable_get_buffer (drawable),
x_coord, y_coord, NULL, pixel, format,
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_channels);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), pixel, num_channels);
}
return return_vals;
}
static GimpValueArray *
drawable_set_pixel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpDrawable *drawable;
gint x_coord;
gint y_coord;
gint num_channels;
const guint8 *pixel;
drawable = g_value_get_object (gimp_value_array_index (args, 0));
x_coord = g_value_get_int (gimp_value_array_index (args, 1));
y_coord = g_value_get_int (gimp_value_array_index (args, 2));
num_channels = g_value_get_int (gimp_value_array_index (args, 3));
pixel = gimp_value_get_uint8_array (gimp_value_array_index (args, 4));
if (success)
{
const Babl *format = gimp_drawable_get_format (drawable);
if (gimp_pdb_item_is_modifiable (GIMP_ITEM (drawable),
GIMP_PDB_ITEM_CONTENT, error) &&
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
y_coord < gimp_item_get_height (GIMP_ITEM (drawable)) &&
num_channels == babl_format_get_bytes_per_pixel (format))
{
gegl_buffer_set (gimp_drawable_get_buffer (drawable),
GEGL_RECTANGLE (x_coord, y_coord, 1, 1),
0, format, pixel, GEGL_AUTO_ROWSTRIDE);
}
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
drawable_fill_invoker (GimpProcedure *procedure,
Gimp *gimp,
@ -771,8 +677,7 @@ drawable_thumbnail_invoker (GimpProcedure *procedure,
gint actual_width = 0;
gint actual_height = 0;
gint bpp = 0;
gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL;
GBytes *thumbnail_data = NULL;
drawable = g_value_get_object (gimp_value_array_index (args, 0));
width = g_value_get_int (gimp_value_array_index (args, 1));
@ -808,9 +713,8 @@ drawable_thumbnail_invoker (GimpProcedure *procedure,
actual_width = gimp_temp_buf_get_width (buf);
actual_height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}
@ -826,8 +730,7 @@ drawable_thumbnail_invoker (GimpProcedure *procedure,
g_value_set_int (gimp_value_array_index (return_vals, 1), actual_width);
g_value_set_int (gimp_value_array_index (return_vals, 2), actual_height);
g_value_set_int (gimp_value_array_index (return_vals, 3), bpp);
g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count);
g_value_take_boxed (gimp_value_array_index (return_vals, 4), thumbnail_data);
}
return return_vals;
@ -853,8 +756,7 @@ drawable_sub_thumbnail_invoker (GimpProcedure *procedure,
gint width = 0;
gint height = 0;
gint bpp = 0;
gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL;
GBytes *thumbnail_data = NULL;
drawable = g_value_get_object (gimp_value_array_index (args, 0));
src_x = g_value_get_int (gimp_value_array_index (args, 1));
@ -887,9 +789,8 @@ drawable_sub_thumbnail_invoker (GimpProcedure *procedure,
width = gimp_temp_buf_get_width (buf);
height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}
@ -908,8 +809,7 @@ drawable_sub_thumbnail_invoker (GimpProcedure *procedure,
g_value_set_int (gimp_value_array_index (return_vals, 1), width);
g_value_set_int (gimp_value_array_index (return_vals, 2), height);
g_value_set_int (gimp_value_array_index (return_vals, 3), bpp);
g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count);
g_value_take_boxed (gimp_value_array_index (return_vals, 4), thumbnail_data);
}
return return_vals;
@ -1547,98 +1447,6 @@ register_drawable_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-get-pixel
*/
procedure = gimp_procedure_new (drawable_get_pixel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-get-pixel");
gimp_procedure_set_static_help (procedure,
"Gets the value of the pixel at the specified coordinates.",
"This procedure gets the pixel value at the specified coordinates. The 'num_channels' argument must always be equal to the bytes-per-pixel value for the specified drawable.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable ("drawable",
"drawable",
"The drawable",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("x-coord",
"x coord",
"The x coordinate",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("y-coord",
"y coord",
"The y coordinate",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-channels",
"num channels",
"The number of channels for the pixel",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("pixel",
"pixel",
"The pixel value",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-set-pixel
*/
procedure = gimp_procedure_new (drawable_set_pixel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-set-pixel");
gimp_procedure_set_static_help (procedure,
"Sets the value of the pixel at the specified coordinates.",
"This procedure sets the pixel value at the specified coordinates. The 'num_channels' argument must always be equal to the bytes-per-pixel value for the specified drawable. Note that this function is not undoable, you should use it only on drawables you just created yourself.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable ("drawable",
"drawable",
"The drawable",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("x-coord",
"x coord",
"The x coordinate",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("y-coord",
"y coord",
"The y coordinate",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-channels",
"num channels",
"The number of channels for the pixel",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("pixel",
"pixel",
"The pixel value",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-fill
*/
@ -1769,16 +1577,11 @@ register_drawable_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("thumbnail-data-count",
"thumbnail data count",
"The number of bytes in thumbnail data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1857,16 +1660,11 @@ register_drawable_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("thumbnail-data-count",
"thumbnail data count",
"The number of bytes in thumbnail data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

26
app/pdb/file-cmds.c
View File

@ -292,8 +292,7 @@ file_load_thumbnail_invoker (GimpProcedure *procedure,
GFile *file;
gint width = 0;
gint height = 0;
gint thumb_data_count = 0;
guint8 *thumb_data = NULL;
GBytes *thumb_data = NULL;
file = g_value_get_object (gimp_value_array_index (args, 0));
@ -305,9 +304,8 @@ file_load_thumbnail_invoker (GimpProcedure *procedure,
{
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
thumb_data_count = 3 * width * height;
thumb_data = g_memdup2 (gdk_pixbuf_get_pixels (pixbuf),
thumb_data_count);
thumb_data = g_bytes_new (gdk_pixbuf_get_pixels (pixbuf),
3 * width * height);
g_object_unref (pixbuf);
}
@ -322,8 +320,7 @@ file_load_thumbnail_invoker (GimpProcedure *procedure,
{
g_value_set_int (gimp_value_array_index (return_vals, 1), width);
g_value_set_int (gimp_value_array_index (return_vals, 2), height);
g_value_set_int (gimp_value_array_index (return_vals, 3), thumb_data_count);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 4), thumb_data, thumb_data_count);
g_value_take_boxed (gimp_value_array_index (return_vals, 3), thumb_data);
}
return return_vals;
@ -571,16 +568,11 @@ register_file_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("thumb-data-count",
"thumb data count",
"The number of bytes in thumbnail data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("thumb-data",
"thumb data",
"The thumbnail data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("thumb-data",
"thumb data",
"The thumbnail data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

5
app/pdb/gimppdb.c
View File

@ -446,7 +446,6 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
}
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_UINT8_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) ||
GIMP_VALUE_HOLDS_RGB_ARRAY (value) ||
GIMP_VALUE_HOLDS_OBJECT_ARRAY (value))
@ -462,10 +461,6 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
gimp_value_set_int32_array (value,
(const gint32 *) va_arg (va_args, gpointer),
prev_int_value);
else if (GIMP_VALUE_HOLDS_UINT8_ARRAY (value))
gimp_value_set_uint8_array (value,
(const guint8 *) va_arg (va_args, gpointer),
prev_int_value);
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
gimp_value_set_float_array (value,
(const gdouble *) va_arg (va_args, gpointer),

82
app/pdb/image-cmds.c
View File

@ -1522,25 +1522,24 @@ image_get_colormap_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_bytes = 0;
guint8 *colormap = NULL;
GBytes *colormap = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
if (success)
{
num_bytes = 3 * gimp_image_get_colormap_size (image);
colormap = gimp_image_get_colormap (image);
guchar *colormap_data;
colormap_data = gimp_image_get_colormap (image);
colormap = g_bytes_new_take (colormap_data,
gimp_image_get_colormap_size (image));
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), colormap, num_bytes);
}
g_value_take_boxed (gimp_value_array_index (return_vals, 1), colormap);
return return_vals;
}
@ -1555,16 +1554,17 @@ image_set_colormap_invoker (GimpProcedure *procedure,
{
gboolean success = TRUE;
GimpImage *image;
gint num_bytes;
const guint8 *colormap;
GBytes *colormap;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_bytes = g_value_get_int (gimp_value_array_index (args, 1));
colormap = gimp_value_get_uint8_array (gimp_value_array_index (args, 2));
colormap = g_value_get_boxed (gimp_value_array_index (args, 1));
if (success)
{
gimp_image_set_colormap (image, colormap, num_bytes / 3, TRUE);
gimp_image_set_colormap (image,
g_bytes_get_data (colormap, NULL),
g_bytes_get_size (colormap) / 3,
TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
@ -1699,8 +1699,7 @@ image_thumbnail_invoker (GimpProcedure *procedure,
gint actual_width = 0;
gint actual_height = 0;
gint bpp = 0;
gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL;
GBytes *thumbnail_data = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
width = g_value_get_int (gimp_value_array_index (args, 1));
@ -1732,9 +1731,8 @@ image_thumbnail_invoker (GimpProcedure *procedure,
actual_width = gimp_temp_buf_get_width (buf);
actual_height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}
@ -1750,8 +1748,7 @@ image_thumbnail_invoker (GimpProcedure *procedure,
g_value_set_int (gimp_value_array_index (return_vals, 1), actual_width);
g_value_set_int (gimp_value_array_index (return_vals, 2), actual_height);
g_value_set_int (gimp_value_array_index (return_vals, 3), bpp);
g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count);
g_value_take_boxed (gimp_value_array_index (return_vals, 4), thumbnail_data);
}
return return_vals;
@ -4318,16 +4315,11 @@ register_image_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the colormap array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("colormap",
"colormap",
"The image's colormap.",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("colormap",
"colormap",
"The image's colormap.",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -4352,16 +4344,11 @@ register_image_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the colormap array",
0, 768, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("colormap",
"colormap",
"The new colormap values",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("colormap",
"colormap",
"The new colormap values",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -4528,16 +4515,11 @@ register_image_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("thumbnail-data-count",
"thumbnail data count",
"The number of bytes in thumbnail data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("thumbnail-data",
"thumbnail data",
"The thumbnail data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

157
app/pdb/image-color-profile-cmds.c
View File

@ -55,8 +55,7 @@ image_get_color_profile_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_bytes = 0;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
@ -73,8 +72,7 @@ image_get_color_profile_invoker (GimpProcedure *procedure,
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
@ -82,10 +80,7 @@ image_get_color_profile_invoker (GimpProcedure *procedure,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes);
}
g_value_take_boxed (gimp_value_array_index (return_vals, 1), profile_data);
return return_vals;
}
@ -101,8 +96,7 @@ image_get_effective_color_profile_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_bytes = 0;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
@ -119,8 +113,7 @@ image_get_effective_color_profile_invoker (GimpProcedure *procedure,
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
@ -128,10 +121,7 @@ image_get_effective_color_profile_invoker (GimpProcedure *procedure,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes);
}
g_value_take_boxed (gimp_value_array_index (return_vals, 1), profile_data);
return return_vals;
}
@ -146,12 +136,10 @@ image_set_color_profile_invoker (GimpProcedure *procedure,
{
gboolean success = TRUE;
GimpImage *image;
gint num_bytes;
const guint8 *color_profile;
GBytes *color_profile;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_bytes = g_value_get_int (gimp_value_array_index (args, 1));
color_profile = gimp_value_get_uint8_array (gimp_value_array_index (args, 2));
color_profile = g_value_get_boxed (gimp_value_array_index (args, 1));
if (success)
{
@ -159,8 +147,8 @@ image_set_color_profile_invoker (GimpProcedure *procedure,
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)
@ -237,8 +225,7 @@ image_get_simulation_profile_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_bytes = 0;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
@ -255,8 +242,7 @@ image_get_simulation_profile_invoker (GimpProcedure *procedure,
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
@ -264,10 +250,7 @@ image_get_simulation_profile_invoker (GimpProcedure *procedure,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes);
}
g_value_take_boxed (gimp_value_array_index (return_vals, 1), profile_data);
return return_vals;
}
@ -282,12 +265,10 @@ image_set_simulation_profile_invoker (GimpProcedure *procedure,
{
gboolean success = TRUE;
GimpImage *image;
gint num_bytes;
const guint8 *color_profile;
GBytes *color_profile;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_bytes = g_value_get_int (gimp_value_array_index (args, 1));
color_profile = gimp_value_get_uint8_array (gimp_value_array_index (args, 2));
color_profile = g_value_get_boxed (gimp_value_array_index (args, 1));
if (success)
{
@ -295,8 +276,8 @@ image_set_simulation_profile_invoker (GimpProcedure *procedure,
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)
@ -478,16 +459,14 @@ image_convert_color_profile_invoker (GimpProcedure *procedure,
{
gboolean success = TRUE;
GimpImage *image;
gint num_bytes;
const guint8 *color_profile;
GBytes *color_profile;
gint intent;
gboolean bpc;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_bytes = g_value_get_int (gimp_value_array_index (args, 1));
color_profile = gimp_value_get_uint8_array (gimp_value_array_index (args, 2));
intent = g_value_get_enum (gimp_value_array_index (args, 3));
bpc = g_value_get_boolean (gimp_value_array_index (args, 4));
color_profile = g_value_get_boxed (gimp_value_array_index (args, 1));
intent = g_value_get_enum (gimp_value_array_index (args, 2));
bpc = g_value_get_boolean (gimp_value_array_index (args, 3));
if (success)
{
@ -495,8 +474,8 @@ image_convert_color_profile_invoker (GimpProcedure *procedure,
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)
@ -588,16 +567,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("profile-data",
"profile data",
"The image's serialized color profile.",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("profile-data",
"profile data",
"The image's serialized color profile.",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -622,16 +596,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("profile-data",
"profile data",
"The image's serialized color profile.",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("profile-data",
"profile data",
"The image's serialized color profile.",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -656,16 +625,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("color-profile",
"color profile",
"The new serialized color profile",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("color-profile",
"color profile",
"The new serialized color profile",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -719,16 +683,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("profile-data",
"profile data",
"The image's serialized simulation color profile.",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("profile-data",
"profile data",
"The image's serialized simulation color profile.",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -753,16 +712,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("color-profile",
"color profile",
"The new serialized simulation color profile",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("color-profile",
"color profile",
"The new serialized simulation color profile",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -934,16 +888,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("color-profile",
"color profile",
"The serialized color profile",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("color-profile",
"color profile",
"The serialized color profile",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("intent",
"intent",

26
app/pdb/image-convert-cmds.c
View File

@ -198,19 +198,18 @@ image_convert_set_dither_matrix_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
gint width;
gint height;
gint matrix_length;
const guint8 *matrix;
GBytes *matrix;
width = g_value_get_int (gimp_value_array_index (args, 0));
height = g_value_get_int (gimp_value_array_index (args, 1));
matrix_length = g_value_get_int (gimp_value_array_index (args, 2));
matrix = gimp_value_get_uint8_array (gimp_value_array_index (args, 3));
matrix = g_value_get_boxed (gimp_value_array_index (args, 2));
if (success)
{
if (width == 0 || height == 0 || matrix_length == width * height)
if (width == 0 || height == 0 || g_bytes_get_size (matrix) == width * height)
{
gimp_image_convert_indexed_set_dither_matrix (matrix, width, height);
gimp_image_convert_indexed_set_dither_matrix (g_bytes_get_data (matrix, NULL),
width, height);
}
else
{
@ -402,16 +401,11 @@ register_image_convert_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("matrix-length",
"matrix length",
"The length of 'matrix'",
1, 1024, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("matrix",
"matrix",
"The matrix -- all values must be >= 1",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("matrix",
"matrix",
"The matrix -- all values must be >= 1",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

2
app/pdb/internal-procs.c
View File

@ -30,7 +30,7 @@
#include "internal-procs.h"
/* 774 procedures registered total */
/* 772 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)

24
app/pdb/pattern-cmds.c
View File

@ -100,8 +100,7 @@ pattern_get_pixels_invoker (GimpProcedure *procedure,
gint width = 0;
gint height = 0;
gint bpp = 0;
gint num_color_bytes = 0;
guint8 *color_bytes = NULL;
GBytes *color_bytes = NULL;
pattern = g_value_get_object (gimp_value_array_index (args, 0));
@ -118,8 +117,7 @@ pattern_get_pixels_invoker (GimpProcedure *procedure,
width = gimp_temp_buf_get_width (pattern->mask);
height = gimp_temp_buf_get_height (pattern->mask);
bpp = babl_format_get_bytes_per_pixel (format);
num_color_bytes = gimp_temp_buf_get_data_size (pattern->mask);
color_bytes = g_memdup2 (data, num_color_bytes);
color_bytes = g_bytes_new (data, gimp_temp_buf_get_data_size (pattern->mask));
gimp_temp_buf_unlock (pattern->mask, data);
}
@ -132,8 +130,7 @@ pattern_get_pixels_invoker (GimpProcedure *procedure,
g_value_set_int (gimp_value_array_index (return_vals, 1), width);
g_value_set_int (gimp_value_array_index (return_vals, 2), height);
g_value_set_int (gimp_value_array_index (return_vals, 3), bpp);
g_value_set_int (gimp_value_array_index (return_vals, 4), num_color_bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 5), color_bytes, num_color_bytes);
g_value_take_boxed (gimp_value_array_index (return_vals, 4), color_bytes);
}
return return_vals;
@ -252,16 +249,11 @@ register_pattern_procs (GimpPDB *pdb)
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-color-bytes",
"num color bytes",
"Number of pattern bytes",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("color-bytes",
"color bytes",
"The pattern data.",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("color-bytes",
"color bytes",
"The pattern data.",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

75
app/pdb/pdb-cmds.c
View File

@ -635,13 +635,11 @@ pdb_set_proc_icon_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
const gchar *procedure_name;
gint icon_type;
gint icon_data_length;
const guint8 *icon_data;
GBytes *icon_data;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
icon_type = g_value_get_enum (gimp_value_array_index (args, 1));
icon_data_length = g_value_get_int (gimp_value_array_index (args, 2));
icon_data = gimp_value_get_uint8_array (gimp_value_array_index (args, 3));
icon_data = g_value_get_boxed (gimp_value_array_index (args, 2));
if (success)
{
@ -652,7 +650,8 @@ pdb_set_proc_icon_invoker (GimpProcedure *procedure,
{
success = gimp_plug_in_set_proc_icon (plug_in, procedure_name,
icon_type,
icon_data, icon_data_length,
g_bytes_get_data (icon_data, NULL),
g_bytes_get_size (icon_data),
error);
}
else
@ -1127,8 +1126,7 @@ pdb_get_data_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *identifier;
gint bytes = 0;
guint8 *data = NULL;
GBytes *data = NULL;
identifier = g_value_get_string (gimp_value_array_index (args, 0));
@ -1137,12 +1135,13 @@ pdb_get_data_invoker (GimpProcedure *procedure,
if (gimp_is_canonical_identifier (identifier))
{
const guint8 *orig_data;
gint bytes;
orig_data = gimp_plug_in_manager_get_data (gimp->plug_in_manager,
identifier, &bytes);
if (orig_data)
data = g_memdup2 (orig_data, bytes);
data = g_bytes_new (orig_data, bytes);
else
success = FALSE;
}
@ -1159,10 +1158,7 @@ pdb_get_data_invoker (GimpProcedure *procedure,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), bytes);
gimp_value_take_uint8_array (gimp_value_array_index (return_vals, 2), data, bytes);
}
g_value_take_boxed (gimp_value_array_index (return_vals, 1), data);
return return_vals;
}
@ -1218,19 +1214,19 @@ pdb_set_data_invoker (GimpProcedure *procedure,
{
gboolean success = TRUE;
const gchar *identifier;
gint bytes;
const guint8 *data;
GBytes *data;
identifier = g_value_get_string (gimp_value_array_index (args, 0));
bytes = g_value_get_int (gimp_value_array_index (args, 1));
data = gimp_value_get_uint8_array (gimp_value_array_index (args, 2));
data = g_value_get_boxed (gimp_value_array_index (args, 1));
if (success)
{
if (gimp_is_canonical_identifier (identifier))
{
gimp_plug_in_manager_set_data (gimp->plug_in_manager,
identifier, bytes, data);
identifier,
g_bytes_get_size (data),
g_bytes_get_data (data, NULL));
}
else
{
@ -1758,16 +1754,11 @@ register_pdb_procs (GimpPDB *pdb)
GIMP_ICON_TYPE_ICON_NAME,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("icon-data-length",
"icon data length",
"The length of 'icon-data'",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("icon-data",
"icon data",
"The procedure's icon. The format depends on the 'icon_type' parameter",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("icon-data",
"icon data",
"The procedure's icon. The format depends on the 'icon_type' parameter",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -2227,16 +2218,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("bytes",
"bytes",
"The number of bytes in the data",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_uint8_array ("data",
"data",
"A byte array containing data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("data",
"data",
"A byte array containing data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -2292,16 +2278,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("bytes",
"bytes",
"The number of bytes in the data",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_uint8_array ("data",
"data",
"A byte array containing data",
GIMP_PARAM_READWRITE));
g_param_spec_boxed ("data",
"data",
"A byte array containing data",
G_TYPE_BYTES,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}

2
app/plug-in/gimpplugin-message.c
View File

@ -730,9 +730,7 @@ gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in,
GPParamDef *prev_param_def = &proc_install->params[i - 1];
if ((! strcmp (param_def->type_name, "GimpParamInt32Array") ||
! strcmp (param_def->type_name, "GimpParamUInt8Array") ||
! strcmp (param_def->type_name, "GimpParamIntFloatArray") ||
! strcmp (param_def->type_name, "GimpParamIntStringArray") ||
! strcmp (param_def->type_name, "GimpParamIntColorArray"))
&&
strcmp (prev_param_def->type_name, "GParamInt"))

16
app/widgets/gimpbrushselect.c
View File

@ -262,17 +262,16 @@ gimp_brush_select_run_callback (GimpPdbDialog *dialog,
GimpTempBuf *mask = gimp_brush_get_mask (brush);
const Babl *format;
gpointer data;
GimpArray *array;
GBytes *bytes;
GimpValueArray *return_vals;
format = gimp_babl_compat_u8_mask_format (gimp_temp_buf_get_format (mask));
data = gimp_temp_buf_lock (mask, format, GEGL_ACCESS_READ);
array = gimp_array_new (data,
gimp_temp_buf_get_width (mask) *
gimp_temp_buf_get_height (mask) *
babl_format_get_bytes_per_pixel (format),
TRUE);
bytes = g_bytes_new_static (data,
gimp_temp_buf_get_width (mask) *
gimp_temp_buf_get_height (mask) *
babl_format_get_bytes_per_pixel (format));
return_vals =
gimp_pdb_execute_procedure_by_name (dialog->pdb,
@ -285,12 +284,11 @@ gimp_brush_select_run_callback (GimpPdbDialog *dialog,
GIMP_TYPE_LAYER_MODE, gimp_context_get_paint_mode (dialog->context),
G_TYPE_INT, gimp_brush_get_width (brush),
G_TYPE_INT, gimp_brush_get_height (brush),
G_TYPE_INT, array->length,
GIMP_TYPE_UINT8_ARRAY, array->data,
G_TYPE_BYTES, bytes,
G_TYPE_BOOLEAN, closing,
G_TYPE_NONE);
gimp_array_free (array);
g_bytes_unref (bytes);
gimp_temp_buf_unlock (mask, data);

16
app/widgets/gimppatternselect.c
View File

@ -107,18 +107,17 @@ gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
GimpPattern *pattern = GIMP_PATTERN (object);
const Babl *format;
gpointer data;
GimpArray *array;
GBytes *bytes;
GimpValueArray *return_vals;
format = gimp_babl_compat_u8_format (
gimp_temp_buf_get_format (pattern->mask));
data = gimp_temp_buf_lock (pattern->mask, format, GEGL_ACCESS_READ);
array = gimp_array_new (data,
gimp_temp_buf_get_width (pattern->mask) *
gimp_temp_buf_get_height (pattern->mask) *
babl_format_get_bytes_per_pixel (format),
TRUE);
bytes = g_bytes_new_static (data,
gimp_temp_buf_get_width (pattern->mask) *
gimp_temp_buf_get_height (pattern->mask) *
babl_format_get_bytes_per_pixel (format));
return_vals =
gimp_pdb_execute_procedure_by_name (dialog->pdb,
@ -129,12 +128,11 @@ gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
G_TYPE_INT, gimp_temp_buf_get_width (pattern->mask),
G_TYPE_INT, gimp_temp_buf_get_height (pattern->mask),
G_TYPE_INT, babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (pattern->mask)),
G_TYPE_INT, array->length,
GIMP_TYPE_UINT8_ARRAY, array->data,
G_TYPE_BYTES, bytes,
G_TYPE_BOOLEAN, closing,
G_TYPE_NONE);
gimp_array_free (array);
g_bytes_unref (bytes);
gimp_temp_buf_unlock (pattern->mask, data);

3
libgimp/gimp.c
View File

@ -426,8 +426,9 @@ gimp_main (GType plug_in_type,
G_TYPE_STRING, G_TYPE_PARAM_STRING,
G_TYPE_STRV, G_TYPE_PARAM_BOXED,
G_TYPE_BYTES, G_TYPE_PARAM_BOXED,
GIMP_TYPE_ARRAY, GIMP_TYPE_PARAM_ARRAY,
GIMP_TYPE_UINT8_ARRAY, GIMP_TYPE_PARAM_UINT8_ARRAY,
GIMP_TYPE_INT32_ARRAY, GIMP_TYPE_PARAM_INT32_ARRAY,
GIMP_TYPE_FLOAT_ARRAY, GIMP_TYPE_PARAM_FLOAT_ARRAY,
GIMP_TYPE_RGB_ARRAY, GIMP_TYPE_PARAM_RGB_ARRAY,

2
libgimp/gimp.def
View File

@ -221,7 +221,6 @@ EXPORTS
gimp_drawable_get_format
gimp_drawable_get_height
gimp_drawable_get_offsets
gimp_drawable_get_pixel
gimp_drawable_get_shadow_buffer
gimp_drawable_get_sub_thumbnail
gimp_drawable_get_sub_thumbnail_data
@ -244,7 +243,6 @@ EXPORTS
gimp_drawable_merge_shadow
gimp_drawable_offset
gimp_drawable_posterize
gimp_drawable_set_pixel
gimp_drawable_shadows_highlights
gimp_drawable_threshold
gimp_drawable_type

18
libgimp/gimpaspectpreview.c
View File

@ -314,31 +314,31 @@ gimp_aspect_preview_draw_buffer (GimpPreview *preview,
}
else
{
guchar *sel;
guchar *src;
GBytes *sel;
GBytes *src;
GimpSelection *selection;
gint w, h;
gint bpp;
selection = gimp_image_get_selection (image);
w = width;
h = height;
src = gimp_drawable_get_thumbnail_data (priv->drawable,
width, height,
&w, &h, &bpp);
sel = gimp_drawable_get_thumbnail_data (GIMP_DRAWABLE (selection),
width, height,
&w, &h, &bpp);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (area),
0, 0, width, height,
gimp_drawable_type (priv->drawable),
src, width * gimp_drawable_get_bpp (priv->drawable),
g_bytes_get_data (src, NULL),
width * gimp_drawable_get_bpp (priv->drawable),
buffer, rowstride,
sel, width);
g_bytes_get_data (sel, NULL), width);
g_free (sel);
g_free (src);
g_bytes_unref (sel);
g_bytes_unref (src);
}
}

22
libgimp/gimpbrush_pdb.c
View File

@ -361,11 +361,9 @@ gimp_brush_get_info (GimpBrush *brush,
* @width: (out): The brush width.
* @height: (out): The brush height.
* @mask_bpp: (out): The brush mask bpp.
* @num_mask_bytes: (out): Length of brush mask data.
* @mask_bytes: (out) (array length=num_mask_bytes) (element-type guint8) (transfer full): The brush mask data.
* @mask_bytes: (out) (transfer full): The brush mask data.
* @color_bpp: (out): The brush color bpp.
* @num_color_bytes: (out): Length of brush color data.
* @color_bytes: (out) (array length=num_color_bytes) (element-type guint8) (transfer full): The brush color data.
* @color_bytes: (out) (transfer full): The brush color data.
*
* Gets information about the brush.
*
@ -382,11 +380,9 @@ gimp_brush_get_pixels (GimpBrush *brush,
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
GBytes **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes)
GBytes **color_bytes)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -404,10 +400,8 @@ gimp_brush_get_pixels (GimpBrush *brush,
*width = 0;
*height = 0;
*mask_bpp = 0;
*num_mask_bytes = 0;
*mask_bytes = NULL;
*color_bpp = 0;
*num_color_bytes = 0;
*color_bytes = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
@ -417,11 +411,9 @@ gimp_brush_get_pixels (GimpBrush *brush,
*width = GIMP_VALUES_GET_INT (return_vals, 1);
*height = GIMP_VALUES_GET_INT (return_vals, 2);
*mask_bpp = GIMP_VALUES_GET_INT (return_vals, 3);
*num_mask_bytes = GIMP_VALUES_GET_INT (return_vals, 4);
*mask_bytes = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
*color_bpp = GIMP_VALUES_GET_INT (return_vals, 6);
*num_color_bytes = GIMP_VALUES_GET_INT (return_vals, 7);
*color_bytes = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 8);
*mask_bytes = GIMP_VALUES_DUP_BYTES (return_vals, 4);
*color_bpp = GIMP_VALUES_GET_INT (return_vals, 5);
*color_bytes = GIMP_VALUES_DUP_BYTES (return_vals, 6);
}
gimp_value_array_unref (return_vals);

6
libgimp/gimpbrush_pdb.h
View File

@ -49,11 +49,9 @@ gboolean gimp_brush_get_pixels (GimpBrush *brush,
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
GBytes **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes);
GBytes **color_bytes);
gint gimp_brush_get_spacing (GimpBrush *brush);
gboolean gimp_brush_set_spacing (GimpBrush *brush,
gint spacing);

13
libgimp/gimpbrushselectbutton.c
View File

@ -405,10 +405,9 @@ gimp_brush_select_button_get_brush_bitmap (GimpBrushSelectButton *self)
{
GimpBrush *brush;
gint mask_bpp;
gint mask_data_size;
GBytes *mask_data;
gint color_bpp;
gint color_data_size;
guint8 *color_data;
GBytes *color_data;
_PreviewBitmap result;
g_debug ("%s", G_STRFUNC);
@ -419,15 +418,13 @@ gimp_brush_select_button_get_brush_bitmap (GimpBrushSelectButton *self)
&result.width,
&result.height,
&mask_bpp,
&mask_data_size,
&result.mask_data,
&mask_data,
&color_bpp,
&color_data_size,
&color_data);
result.mask_data = g_bytes_unref_to_data (mask_data, NULL);
/* Discard any color data, bitmap is B&W i.e. i.e. depth one i.e. a mask */
if (color_data)
g_free (color_data);
g_bytes_unref (color_data);
return result;
}

116
libgimp/gimpdrawable.c
View File

@ -73,39 +73,40 @@ gimp_drawable_get_by_id (gint32 drawable_id)
/**
* gimp_drawable_get_thumbnail_data:
* @drawable: the drawable
* @width: (inout): the requested thumbnail width (<= 1024 pixels)
* @height: (inout): the requested thumbnail height (<= 1024 pixels)
* @bpp: (out): the bytes per pixel of the returned thubmnail data
* @width: the requested thumbnail width (<= 1024 pixels)
* @height: the requested thumbnail height (<= 1024 pixels)
* @actual_width: (out): the resulting thumbnail's actual width
* @actual_height: (out): the resulting thumbnail's actual height
* @bpp: (out): the bytes per pixel of the returned thubmnail data
*
* Retrieves thumbnail data for the drawable identified by @drawable.
* The thumbnail will be not larger than the requested size.
*
* Returns: (transfer full) (array) (nullable): thumbnail data or %NULL if
* Returns: (transfer full) (nullable): thumbnail data or %NULL if
* @drawable is invalid.
**/
guchar *
GBytes *
gimp_drawable_get_thumbnail_data (GimpDrawable *drawable,
gint *width,
gint *height,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp)
{
gint ret_width;
gint ret_height;
guchar *image_data;
gint data_size;
GBytes *image_data;
g_return_val_if_fail (actual_width != NULL, NULL);
g_return_val_if_fail (actual_height != NULL, NULL);
g_return_val_if_fail (bpp != NULL, NULL);
_gimp_drawable_thumbnail (drawable,
*width,
*height,
&ret_width,
&ret_height,
width,
height,
actual_width,
actual_height,
bpp,
&data_size,
&image_data);
*width = ret_width;
*height = ret_height;
return image_data;
}
@ -130,25 +131,27 @@ gimp_drawable_get_thumbnail (GimpDrawable *drawable,
gint height,
GimpPixbufTransparency alpha)
{
gint thumb_width = width;
gint thumb_height = height;
gint thumb_bpp;
guchar *data;
gint thumb_width, thumb_height, thumb_bpp;
GBytes *data;
GdkPixbuf *pixbuf = NULL;
g_return_val_if_fail (width > 0 && width <= 1024, NULL);
g_return_val_if_fail (height > 0 && height <= 1024, NULL);
data = gimp_drawable_get_thumbnail_data (drawable,
width,
height,
&thumb_width,
&thumb_height,
&thumb_bpp);
if (data)
return _gimp_pixbuf_from_data (data,
thumb_width, thumb_height, thumb_bpp,
alpha);
pixbuf = _gimp_pixbuf_from_data (g_bytes_unref_to_data (data, NULL),
thumb_width, thumb_height, thumb_bpp,
alpha);
return NULL;
g_bytes_unref (data);
return pixbuf;
}
/**
@ -158,46 +161,48 @@ gimp_drawable_get_thumbnail (GimpDrawable *drawable,
* @src_y: the y coordinate of the area
* @src_width: the width of the area
* @src_height: the height of the area
* @dest_width: (inout): the requested thumbnail width (<= 1024 pixels)
* @dest_height: (inout): the requested thumbnail height (<= 1024 pixels)
* @dest_width: the requested thumbnail width (<= 1024 pixels)
* @dest_height: the requested thumbnail height (<= 1024 pixels)
* @actual_width: (out): the width of the returned thumbnail
* @actual_height: (out): the height of the returned thumbnail
* @bpp: (out): the bytes per pixel of the returned thumbnail data
*
* Retrieves thumbnail data for the drawable identified by @drawable.
* The thumbnail will be not larger than the requested size.
*
* Returns: (transfer full) (array) (nullable): thumbnail data or %NULL if
* Returns: (transfer full): thumbnail data or %NULL if
* @drawable is invalid.
**/
guchar *
GBytes *
gimp_drawable_get_sub_thumbnail_data (GimpDrawable *drawable,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint *dest_width,
gint *dest_height,
gint dest_width,
gint dest_height,
gint *actual_width,
gint *actual_height,
gint *bpp)
{
gint ret_width;
gint ret_height;
guchar *image_data;
gint data_size;
gint ret_width, ret_height;
GBytes *image_bytes;
gsize data_size;
_gimp_drawable_sub_thumbnail (drawable,
src_x, src_y,
src_width, src_height,
*dest_width,
*dest_height,
dest_width,
dest_height,
&ret_width,
&ret_height,
bpp,
&data_size,
&image_data);
&image_bytes);
*dest_width = ret_width;
*dest_height = ret_height;
*actual_width = ret_width;
*actual_height = ret_height;
return image_data;
return g_bytes_unref_to_data (image_bytes, &data_size);
}
/**
@ -229,10 +234,11 @@ gimp_drawable_get_sub_thumbnail (GimpDrawable *drawable,
gint dest_height,
GimpPixbufTransparency alpha)
{
gint thumb_width = dest_width;
gint thumb_height = dest_height;
gint thumb_bpp;
guchar *data;
gint thumb_width = dest_width;
gint thumb_height = dest_height;
gint thumb_bpp;
GBytes *data;
GdkPixbuf *pixbuf = NULL;
g_return_val_if_fail (src_x >= 0, NULL);
g_return_val_if_fail (src_y >= 0, NULL);
@ -244,16 +250,18 @@ gimp_drawable_get_sub_thumbnail (GimpDrawable *drawable,
data = gimp_drawable_get_sub_thumbnail_data (drawable,
src_x, src_y,
src_width, src_height,
dest_width, dest_height,
&thumb_width,
&thumb_height,
&thumb_bpp);
if (data)
return _gimp_pixbuf_from_data (data,
thumb_width, thumb_height, thumb_bpp,
alpha);
pixbuf = _gimp_pixbuf_from_data (g_bytes_unref_to_data (data, NULL),
thumb_width, thumb_height, thumb_bpp,
alpha);
g_bytes_unref (data);
return NULL;
return pixbuf;
}
/**
@ -375,7 +383,7 @@ gimp_drawable_get_format (GimpDrawable *drawable)
const Babl *palette;
const Babl *palette_alpha;
guchar *colormap;
gint n_colors;
gint colormap_len, n_colors;
babl_new_palette_with_space (format_str, space,
&palette, &palette_alpha);
@ -385,7 +393,7 @@ gimp_drawable_get_format (GimpDrawable *drawable)
else
format = palette;
colormap = gimp_image_get_colormap (image, &n_colors);
colormap = gimp_image_get_colormap (image, &colormap_len, &n_colors);
if (colormap)
{

16
libgimp/gimpdrawable.h
View File

@ -62,22 +62,26 @@ GeglBuffer * gimp_drawable_get_shadow_buffer (GimpDrawable *drawable);
const Babl * gimp_drawable_get_format (GimpDrawable *drawable);
const Babl * gimp_drawable_get_thumbnail_format (GimpDrawable *drawable);
guchar * gimp_drawable_get_thumbnail_data (GimpDrawable *drawable,
gint *width,
gint *height,
GBytes * gimp_drawable_get_thumbnail_data (GimpDrawable *drawable,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp);
GdkPixbuf * gimp_drawable_get_thumbnail (GimpDrawable *drawable,
gint width,
gint height,
GimpPixbufTransparency alpha);
guchar * gimp_drawable_get_sub_thumbnail_data (GimpDrawable *drawable,
GBytes * gimp_drawable_get_sub_thumbnail_data (GimpDrawable *drawable,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint *dest_width,
gint *dest_height,
gint dest_width,
gint dest_height,
gint *actual_width,
gint *actual_height,
gint *bpp);
GdkPixbuf * gimp_drawable_get_sub_thumbnail (GimpDrawable *drawable,
gint src_x,

121
libgimp/gimpdrawable_pdb.c
View File

@ -717,107 +717,6 @@ gimp_drawable_update (GimpDrawable *drawable,
return success;
}
/**
* gimp_drawable_get_pixel:
* @drawable: The drawable.
* @x_coord: The x coordinate.
* @y_coord: The y coordinate.
* @num_channels: (out): The number of channels for the pixel.
*
* Gets the value of the pixel at the specified coordinates.
*
* This procedure gets the pixel value at the specified coordinates.
* The 'num_channels' argument must always be equal to the
* bytes-per-pixel value for the specified drawable.
*
* Returns: (array length=num_channels) (element-type guint8) (transfer full):
* The pixel value.
* The returned value must be freed with g_free().
**/
guint8 *
gimp_drawable_get_pixel (GimpDrawable *drawable,
gint x_coord,
gint y_coord,
gint *num_channels)
{
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *pixel = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_INT, x_coord,
G_TYPE_INT, y_coord,
G_TYPE_NONE);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-get-pixel",
args);
gimp_value_array_unref (args);
*num_channels = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_channels = GIMP_VALUES_GET_INT (return_vals, 1);
pixel = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
gimp_value_array_unref (return_vals);
return pixel;
}
/**
* gimp_drawable_set_pixel:
* @drawable: The drawable.
* @x_coord: The x coordinate.
* @y_coord: The y coordinate.
* @num_channels: The number of channels for the pixel.
* @pixel: (array length=num_channels) (element-type guint8): The pixel value.
*
* Sets the value of the pixel at the specified coordinates.
*
* This procedure sets the pixel value at the specified coordinates.
* The 'num_channels' argument must always be equal to the
* bytes-per-pixel value for the specified drawable. Note that this
* function is not undoable, you should use it only on drawables you
* just created yourself.
*
* Returns: TRUE on success.
**/
gboolean
gimp_drawable_set_pixel (GimpDrawable *drawable,
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_INT, x_coord,
G_TYPE_INT, y_coord,
G_TYPE_INT, num_channels,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 4), pixel, num_channels);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-set-pixel",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_drawable_fill:
* @drawable: The drawable.
@ -923,8 +822,7 @@ gimp_drawable_offset (GimpDrawable *drawable,
* @actual_width: (out): The previews width.
* @actual_height: (out): The previews height.
* @bpp: (out): The previews bpp.
* @thumbnail_data_count: (out): The number of bytes in thumbnail data.
* @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The thumbnail data.
* @thumbnail_data: (out) (transfer full): The thumbnail data.
*
* Get a thumbnail of a drawable.
*
@ -942,8 +840,7 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
GBytes **thumbnail_data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -963,7 +860,6 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
*actual_width = 0;
*actual_height = 0;
*bpp = 0;
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
@ -973,8 +869,7 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
*actual_width = GIMP_VALUES_GET_INT (return_vals, 1);
*actual_height = GIMP_VALUES_GET_INT (return_vals, 2);
*bpp = GIMP_VALUES_GET_INT (return_vals, 3);
*thumbnail_data_count = GIMP_VALUES_GET_INT (return_vals, 4);
*thumbnail_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
*thumbnail_data = GIMP_VALUES_DUP_BYTES (return_vals, 4);
}
gimp_value_array_unref (return_vals);
@ -994,8 +889,7 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
* @width: (out): The previews width.
* @height: (out): The previews height.
* @bpp: (out): The previews bpp.
* @thumbnail_data_count: (out): The number of bytes in thumbnail data.
* @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The thumbnail data.
* @thumbnail_data: (out) (transfer full): The thumbnail data.
*
* Get a thumbnail of a sub-area of a drawable drawable.
*
@ -1019,8 +913,7 @@ _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
GBytes **thumbnail_data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -1044,7 +937,6 @@ _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
*width = 0;
*height = 0;
*bpp = 0;
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
@ -1054,8 +946,7 @@ _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
*width = GIMP_VALUES_GET_INT (return_vals, 1);
*height = GIMP_VALUES_GET_INT (return_vals, 2);
*bpp = GIMP_VALUES_GET_INT (return_vals, 3);
*thumbnail_data_count = GIMP_VALUES_GET_INT (return_vals, 4);
*thumbnail_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
*thumbnail_data = GIMP_VALUES_DUP_BYTES (return_vals, 4);
}
gimp_value_array_unref (return_vals);

15
libgimp/gimpdrawable_pdb.h
View File

@ -64,15 +64,6 @@ gboolean gimp_drawable_update (GimpDrawable
gint y,
gint width,
gint height);
guint8* gimp_drawable_get_pixel (GimpDrawable *drawable,
gint x_coord,
gint y_coord,
gint *num_channels);
gboolean gimp_drawable_set_pixel (GimpDrawable *drawable,
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel);
gboolean gimp_drawable_fill (GimpDrawable *drawable,
GimpFillType fill_type);
gboolean gimp_drawable_offset (GimpDrawable *drawable,
@ -86,8 +77,7 @@ G_GNUC_INTERNAL gboolean _gimp_drawable_thumbnail (GimpDrawable
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data);
GBytes **thumbnail_data);
G_GNUC_INTERNAL gboolean _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
gint src_x,
gint src_y,
@ -98,8 +88,7 @@ G_GNUC_INTERNAL gboolean _gimp_drawable_sub_thumbnail (GimpDrawable
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data);
GBytes **thumbnail_data);
gboolean gimp_drawable_foreground_extract (GimpDrawable *drawable,
GimpForegroundExtractMode mode,
GimpDrawable *mask);

59
libgimp/gimpdrawablepreview.c
View File

@ -266,8 +266,9 @@ static void
gimp_drawable_preview_draw_original (GimpPreview *preview)
{
GimpDrawablePreviewPrivate *priv = GET_PRIVATE (preview);
guchar *buffer;
GBytes *buffer;
gint width, height;
gint tn_width, tn_height;
gint xoff, yoff;
gint xmin, ymin;
gint xmax, ymax;
@ -290,7 +291,8 @@ gimp_drawable_preview_draw_original (GimpPreview *preview)
xoff + xmin,
yoff + ymin,
width, height,
&width, &height, &bpp);
width, height,
&tn_width, &tn_height, &bpp);
switch (bpp)
{
@ -299,13 +301,14 @@ gimp_drawable_preview_draw_original (GimpPreview *preview)
case 3: type = GIMP_RGB_IMAGE; break;
case 4: type = GIMP_RGBA_IMAGE; break;
default:
g_free (buffer);
g_bytes_unref (buffer);
return;
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (gimp_preview_get_area (preview)),
0, 0, width, height, type, buffer, width * bpp);
g_free (buffer);
0, 0, tn_width, tn_height, type,
g_bytes_get_data (buffer, NULL), width * bpp);
g_bytes_unref (buffer);
}
static void
@ -327,11 +330,12 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area,
gint width,
gint height)
{
guchar *buffer;
GBytes *buffer;
gint x1, y1, x2, y2;
gint bpp;
gint size = 100;
gint nav_width, nav_height;
gint tn_width, tn_height;
g_return_if_fail (GIMP_IS_PREVIEW_AREA (area));
g_return_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)));
@ -363,13 +367,15 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area,
{
buffer = gimp_drawable_get_sub_thumbnail_data (drawable,
x1, y1, x2 - x1, y2 - y1,
&nav_width, &nav_height,
nav_width, nav_height,
&tn_width, &tn_height,
&bpp);
}
else
{
buffer = gimp_drawable_get_thumbnail_data (drawable,
&nav_width, &nav_height,
nav_width, nav_height,
&tn_width, &tn_height,
&bpp);
}
@ -377,7 +383,7 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area,
{
GimpImageType type;
gtk_widget_set_size_request (GTK_WIDGET (area), nav_width, nav_height);
gtk_widget_set_size_request (GTK_WIDGET (area), tn_width, tn_height);
gtk_widget_show (GTK_WIDGET (area));
gtk_widget_realize (GTK_WIDGET (area));
@ -388,14 +394,15 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area,
case 3: type = GIMP_RGB_IMAGE; break;
case 4: type = GIMP_RGBA_IMAGE; break;
default:
g_free (buffer);
g_bytes_unref (buffer);
return;
}
gimp_preview_area_draw (area,
0, 0, nav_width, nav_height,
type, buffer, bpp * nav_width);
g_free (buffer);
0, 0, tn_width, tn_height,
type,
g_bytes_get_data (buffer, NULL), bpp * tn_width);
g_bytes_unref (buffer);
}
}
@ -451,22 +458,17 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
{
GimpImageType type;
GimpSelection *selection;
guchar *src;
guchar *sel;
GBytes *src;
GBytes *sel;
gint d_w, d_h, d_bpp;
gint s_w, s_h, s_bpp;
d_w = draw_width;
d_h = draw_height;
s_w = draw_width;
s_h = draw_height;
selection = gimp_image_get_selection (image);
src = gimp_drawable_get_sub_thumbnail_data (priv->drawable,
draw_x, draw_y,
draw_width, draw_height,
draw_width, draw_height,
&d_w, &d_h,
&d_bpp);
@ -474,6 +476,7 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
draw_x + offset_x,
draw_y + offset_y,
draw_width, draw_height,
draw_width, draw_height,
&s_w, &s_h,
&s_bpp);
@ -484,8 +487,8 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
case 3: type = GIMP_RGB_IMAGE; break;
case 4: type = GIMP_RGBA_IMAGE; break;
default:
g_free (sel);
g_free (src);
g_bytes_unref (sel);
g_bytes_unref (src);
return;
}
@ -495,15 +498,15 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
draw_width,
draw_height,
type,
src, draw_width * d_bpp,
g_bytes_get_data (src, NULL), draw_width * d_bpp,
(buf +
(draw_x - x) * d_bpp +
(draw_y - y) * d_w * d_bpp),
rowstride,
sel, s_w);
g_bytes_get_data (sel, NULL), s_w);
g_free (sel);
g_free (src);
g_bytes_unref (sel);
g_bytes_unref (src);
}
}
}
@ -548,7 +551,7 @@ gimp_drawable_preview_set_drawable (GimpDrawablePreview *drawable_preview,
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
gimp_preview_area_set_colormap (GIMP_PREVIEW_AREA (area),
cmap, num_colors);
g_free (cmap);

2
libgimp/gimpexport.c
View File

@ -1101,7 +1101,7 @@ gimp_export_image (GimpImage **image,
{
gint n_colors;
g_free (gimp_image_get_colormap (*image, &n_colors));
g_free (gimp_image_get_colormap (*image, NULL, &n_colors));
if (n_colors > 2)
actions = g_slist_prepend (actions,

39
libgimp/gimpgpparams-body.c
View File

@ -41,9 +41,6 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def)
if (! strcmp (param_def->type_name, "GimpParamInt32Array"))
return gimp_param_spec_int32_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamUInt8Array"))
return gimp_param_spec_uint8_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamFloatArray"))
return gimp_param_spec_float_array (name, nick, blurb, flags);
@ -71,6 +68,10 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def)
! strcmp (param_def->value_type_name, "GStrv"))
return g_param_spec_boxed (name, nick, blurb, G_TYPE_STRV, flags);
if (! strcmp (param_def->type_name, "GParamBoxed") &&
! strcmp (param_def->value_type_name, "GBytes"))
return g_param_spec_boxed (name, nick, blurb, G_TYPE_BYTES, flags);
break;
case GP_PARAM_DEF_TYPE_INT:
@ -647,6 +648,10 @@ gimp_gp_param_to_value (gpointer gimp,
{
g_value_set_boxed (value, param->data.d_strv);
}
else if (G_VALUE_HOLDS (value, G_TYPE_BYTES))
{
g_value_set_boxed (value, param->data.d_bytes);
}
else if (G_VALUE_TYPE (value) == G_TYPE_FILE)
{
g_value_take_object (value, (param->data.d_string ?
@ -668,13 +673,6 @@ gimp_gp_param_to_value (gpointer gimp,
param->data.d_array.size /
sizeof (gint32));
}
else if (GIMP_VALUE_HOLDS_UINT8_ARRAY (value))
{
gimp_value_set_uint8_array (value,
param->data.d_array.data,
param->data.d_array.size /
sizeof (guint8));
}
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
{
gimp_value_set_float_array (value,
@ -955,7 +953,6 @@ gimp_value_to_gp_param (const GValue *value,
}
}
else if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_UINT8_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) ||
GIMP_VALUE_HOLDS_RGB_ARRAY (value))
{
@ -979,6 +976,22 @@ gimp_value_to_gp_param (const GValue *value,
param->data.d_array.data = NULL;
}
}
else if (G_VALUE_HOLDS (value, G_TYPE_BYTES))
{
GBytes *bytes = g_value_get_boxed (value);
param->param_type = GP_PARAM_TYPE_BYTES;
if (bytes != NULL)
{
if (full_copy)
param->data.d_bytes = g_bytes_new (g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes));
else
param->data.d_bytes = g_bytes_new_static (g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes));
}
}
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
gchar **array = g_value_get_boxed (value);
@ -1169,6 +1182,10 @@ _gimp_gp_params_free (GPParam *params,
g_strfreev (params[i].data.d_strv);
break;
case GP_PARAM_TYPE_BYTES:
g_bytes_unref (params[i].data.d_bytes);
break;
case GP_PARAM_TYPE_ID_ARRAY:
if (full_copy)
g_free (params[i].data.d_id_array.type_name);

30
libgimp/gimpimage.c
View File

@ -566,7 +566,8 @@ gimp_image_list_selected_drawables (GimpImage *image)
/**
* gimp_image_get_colormap:
* @image: The image.
* @num_colors: (out): Returns the number of colors in the colormap array.
* @colormap_len: (out) (optional): The size (in bytes) of the returned colormap
* @num_colors: (out) (optional): Returns the number of colors in the colormap array.
*
* Returns the image's colormap
*
@ -574,17 +575,22 @@ gimp_image_list_selected_drawables (GimpImage *image)
* well as the number of colors contained in the colormap. If the image
* is not of base type INDEXED, this pointer will be NULL.
*
* Returns: (array): The image's colormap.
* Returns: (array length=colormap_len): The image's colormap.
*/
guchar *
gimp_image_get_colormap (GimpImage *image,
gint *colormap_len,
gint *num_colors)
{
gint num_bytes;
GBytes *bytes;
gsize num_bytes;
guchar *cmap;
cmap = _gimp_image_get_colormap (image, &num_bytes);
bytes = _gimp_image_get_colormap (image);
cmap = g_bytes_unref_to_data (bytes, &num_bytes);
if (colormap_len)
*colormap_len = num_bytes;
if (num_colors)
*num_colors = num_bytes / 3;
@ -611,7 +617,14 @@ gimp_image_set_colormap (GimpImage *image,
const guchar *colormap,
gint num_colors)
{
return _gimp_image_set_colormap (image, num_colors * 3, colormap);
GBytes *bytes;
gboolean ret;
bytes = g_bytes_new_static (colormap, num_colors * 3);
ret = _gimp_image_set_colormap (image, bytes);
g_bytes_unref (bytes);
return ret;
}
/**
@ -638,8 +651,9 @@ gimp_image_get_thumbnail_data (GimpImage *image,
{
gint ret_width;
gint ret_height;
GBytes *image_bytes;
guchar *image_data;
gint data_size;
gsize data_size;
_gimp_image_thumbnail (image,
*width,
@ -647,8 +661,8 @@ gimp_image_get_thumbnail_data (GimpImage *image,
&ret_width,
&ret_height,
bpp,
&data_size,
&image_data);
&image_bytes);
image_data = g_bytes_unref_to_data (image_bytes, &data_size);
*width = ret_width;
*height = ret_height;

1
libgimp/gimpimage.h
View File

@ -59,6 +59,7 @@ gboolean gimp_image_take_selected_vectors (GimpImage *image,
GList * gimp_image_list_selected_drawables(GimpImage *image);
guchar * gimp_image_get_colormap (GimpImage *image,
gint *colormap_len,
gint *num_colors);
gboolean gimp_image_set_colormap (GimpImage *image,
const guchar *colormap,

41
libgimp/gimpimage_pdb.c
View File

@ -1746,7 +1746,6 @@ gimp_image_merge_layer_group (GimpImage *image,
/**
* _gimp_image_get_colormap:
* @image: The image.
* @num_bytes: (out): Number of bytes in the colormap array.
*
* Returns the image's colormap
*
@ -1756,17 +1755,14 @@ gimp_image_merge_layer_group (GimpImage *image,
* 3. If the image is not in Indexed color mode, no colormap is
* returned.
*
* Returns: (array length=num_bytes) (element-type guint8) (transfer full):
* The image's colormap.
* The returned value must be freed with g_free().
* Returns: (transfer full): The image's colormap.
**/
guint8 *
_gimp_image_get_colormap (GimpImage *image,
gint *num_bytes)
GBytes *
_gimp_image_get_colormap (GimpImage *image)
{
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *colormap = NULL;
GBytes *colormap = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
@ -1777,13 +1773,8 @@ _gimp_image_get_colormap (GimpImage *image,
args);
gimp_value_array_unref (args);
*num_bytes = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_bytes = GIMP_VALUES_GET_INT (return_vals, 1);
colormap = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
colormap = GIMP_VALUES_DUP_BYTES (return_vals, 1);
gimp_value_array_unref (return_vals);
@ -1793,8 +1784,7 @@ _gimp_image_get_colormap (GimpImage *image,
/**
* _gimp_image_set_colormap:
* @image: The image.
* @num_bytes: Number of bytes in the colormap array.
* @colormap: (array length=num_bytes) (element-type guint8): The new colormap values.
* @colormap: The new colormap values.
*
* Sets the entries in the image's colormap.
*
@ -1807,9 +1797,8 @@ _gimp_image_get_colormap (GimpImage *image,
* Returns: TRUE on success.
**/
gboolean
_gimp_image_set_colormap (GimpImage *image,
gint num_bytes,
const guint8 *colormap)
_gimp_image_set_colormap (GimpImage *image,
GBytes *colormap)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -1817,10 +1806,8 @@ _gimp_image_set_colormap (GimpImage *image,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_bytes,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, colormap,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-set-colormap",
@ -1988,8 +1975,7 @@ gimp_image_is_dirty (GimpImage *image)
* @actual_width: (out): The previews width.
* @actual_height: (out): The previews height.
* @bpp: (out): The previews bpp.
* @thumbnail_data_count: (out): The number of bytes in thumbnail data.
* @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The thumbnail data.
* @thumbnail_data: (out) (transfer full): The thumbnail data.
*
* Get a thumbnail of an image.
*
@ -2007,8 +1993,7 @@ _gimp_image_thumbnail (GimpImage *image,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
GBytes **thumbnail_data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -2028,7 +2013,6 @@ _gimp_image_thumbnail (GimpImage *image,
*actual_width = 0;
*actual_height = 0;
*bpp = 0;
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
@ -2038,8 +2022,7 @@ _gimp_image_thumbnail (GimpImage *image,
*actual_width = GIMP_VALUES_GET_INT (return_vals, 1);
*actual_height = GIMP_VALUES_GET_INT (return_vals, 2);
*bpp = GIMP_VALUES_GET_INT (return_vals, 3);
*thumbnail_data_count = GIMP_VALUES_GET_INT (return_vals, 4);
*thumbnail_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
*thumbnail_data = GIMP_VALUES_DUP_BYTES (return_vals, 4);
}
gimp_value_array_unref (return_vals);

9
libgimp/gimpimage_pdb.h
View File

@ -115,11 +115,9 @@ GimpLayer* gimp_image_merge_down (GimpImage
GimpMergeType merge_type);
GimpLayer* gimp_image_merge_layer_group (GimpImage *image,
GimpLayer *layer_group);
G_GNUC_INTERNAL guint8* _gimp_image_get_colormap (GimpImage *image,
gint *num_bytes);
G_GNUC_INTERNAL GBytes* _gimp_image_get_colormap (GimpImage *image);
G_GNUC_INTERNAL gboolean _gimp_image_set_colormap (GimpImage *image,
gint num_bytes,
const guint8 *colormap);
GBytes *colormap);
G_GNUC_INTERNAL gchar* _gimp_image_get_metadata (GimpImage *image);
G_GNUC_INTERNAL gboolean _gimp_image_set_metadata (GimpImage *image,
const gchar *metadata_string);
@ -131,8 +129,7 @@ G_GNUC_INTERNAL gboolean _gimp_image_thumbnail (GimpImage
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data);
GBytes **thumbnail_data);
GimpLayer** gimp_image_get_selected_layers (GimpImage *image,
gint *num_layers);
gboolean gimp_image_set_selected_layers (GimpImage *image,

66
libgimp/gimpimagecolorprofile.c
View File

@ -40,17 +40,17 @@
GimpColorProfile *
gimp_image_get_color_profile (GimpImage *image)
{
guint8 *data;
gint length;
data = _gimp_image_get_color_profile (image, &length);
GBytes *data;
data = _gimp_image_get_color_profile (image);
if (data)
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (data, length, NULL);
g_free (data);
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (data, NULL),
g_bytes_get_size (data),
NULL);
g_bytes_unref (data);
return profile;
}
@ -61,7 +61,7 @@ gimp_image_get_color_profile (GimpImage *image)
/**
* gimp_image_set_color_profile:
* @image: The image.
* @profile: A #GimpColorProfile, or %NULL.
* @profile: (nullable): A #GimpColorProfile, or %NULL.
*
* Sets the image's color profile
*
@ -76,7 +76,8 @@ gimp_image_set_color_profile (GimpImage *image,
GimpColorProfile *profile)
{
const guint8 *data = NULL;
gint length = 0;
GBytes *bytes = NULL;
gboolean ret;
g_return_val_if_fail (profile == NULL || GIMP_IS_COLOR_PROFILE (profile),
FALSE);
@ -86,10 +87,13 @@ gimp_image_set_color_profile (GimpImage *image,
gsize l;
data = gimp_color_profile_get_icc_profile (profile, &l);
length = l;
bytes = g_bytes_new_static (data, l);
}
return _gimp_image_set_color_profile (image, length, data);
ret = _gimp_image_set_color_profile (image, bytes);
g_bytes_unref (bytes);
return ret;
}
/**
@ -109,17 +113,17 @@ gimp_image_set_color_profile (GimpImage *image,
GimpColorProfile *
gimp_image_get_simulation_profile (GimpImage *image)
{
guint8 *data;
gint length;
data = _gimp_image_get_simulation_profile (image, &length);
GBytes *data;
data = _gimp_image_get_simulation_profile (image);
if (data)
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (data, length, NULL);
g_free (data);
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (data, NULL),
g_bytes_get_size (data),
NULL);
g_bytes_unref (data);
return profile;
}
@ -145,7 +149,8 @@ gimp_image_set_simulation_profile (GimpImage *image,
GimpColorProfile *profile)
{
const guint8 *data = NULL;
gint length = 0;
GBytes *bytes = NULL;
gboolean ret;
g_return_val_if_fail (profile == NULL || GIMP_IS_COLOR_PROFILE (profile),
FALSE);
@ -155,10 +160,12 @@ gimp_image_set_simulation_profile (GimpImage *image,
gsize l;
data = gimp_color_profile_get_icc_profile (profile, &l);
length = l;
bytes = g_bytes_new_static (data, l);
}
return _gimp_image_set_simulation_profile (image, length, data);
ret = _gimp_image_set_simulation_profile (image, bytes);
g_bytes_unref (bytes);
return ret;
}
/**
@ -182,17 +189,18 @@ gimp_image_set_simulation_profile (GimpImage *image,
GimpColorProfile *
gimp_image_get_effective_color_profile (GimpImage *image)
{
guint8 *data;
gint length;
GBytes *data;
data = _gimp_image_get_effective_color_profile (image, &length);
data = _gimp_image_get_effective_color_profile (image);
if (data)
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (data, length, NULL);
g_free (data);
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (data, NULL),
g_bytes_get_size (data),
NULL);
g_bytes_unref (data);
return profile;
}
@ -224,7 +232,8 @@ gimp_image_convert_color_profile (GimpImage *image,
gboolean bpc)
{
const guint8 *data = NULL;
gint length = 0;
GBytes *bytes = NULL;
gboolean ret;
g_return_val_if_fail (profile == NULL || GIMP_IS_COLOR_PROFILE (profile),
FALSE);
@ -234,9 +243,10 @@ gimp_image_convert_color_profile (GimpImage *image,
gsize l;
data = gimp_color_profile_get_icc_profile (profile, &l);
length = l;
bytes = g_bytes_new_static (data, l);
}
return _gimp_image_convert_color_profile (image, length, data,
intent, bpc);
ret = _gimp_image_convert_color_profile (image, bytes, intent, bpc);
g_bytes_unref (bytes);
return ret;
}

91
libgimp/gimpimagecolorprofile_pdb.c
View File

@ -39,26 +39,22 @@
/**
* _gimp_image_get_color_profile:
* @image: The image.
* @num_bytes: (out): Number of bytes in the color_profile array.
*
* Returns the image's color profile
*
* This procedure returns the image's color profile, or NULL if the
* image has no color profile assigned.
*
* Returns: (array length=num_bytes) (element-type guint8) (transfer full):
* The image's serialized color profile.
* The returned value must be freed with g_free().
* Returns: (transfer full): The image's serialized color profile.
*
* Since: 2.10
**/
guint8 *
_gimp_image_get_color_profile (GimpImage *image,
gint *num_bytes)
GBytes *
_gimp_image_get_color_profile (GimpImage *image)
{
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
@ -69,13 +65,8 @@ _gimp_image_get_color_profile (GimpImage *image,
args);
gimp_value_array_unref (args);
*num_bytes = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_bytes = GIMP_VALUES_GET_INT (return_vals, 1);
profile_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
profile_data = GIMP_VALUES_DUP_BYTES (return_vals, 1);
gimp_value_array_unref (return_vals);
@ -85,7 +76,6 @@ _gimp_image_get_color_profile (GimpImage *image,
/**
* _gimp_image_get_effective_color_profile:
* @image: The image.
* @num_bytes: (out): Number of bytes in the color_profile array.
*
* Returns the color profile that is used for the image
*
@ -95,19 +85,16 @@ _gimp_image_get_color_profile (GimpImage *image,
* or a generated default RGB or grayscale profile, according to the
* image's type.
*
* Returns: (array length=num_bytes) (element-type guint8) (transfer full):
* The image's serialized color profile.
* The returned value must be freed with g_free().
* Returns: (transfer full): The image's serialized color profile.
*
* Since: 2.10
**/
guint8 *
_gimp_image_get_effective_color_profile (GimpImage *image,
gint *num_bytes)
GBytes *
_gimp_image_get_effective_color_profile (GimpImage *image)
{
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
@ -118,13 +105,8 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
args);
gimp_value_array_unref (args);
*num_bytes = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_bytes = GIMP_VALUES_GET_INT (return_vals, 1);
profile_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
profile_data = GIMP_VALUES_DUP_BYTES (return_vals, 1);
gimp_value_array_unref (return_vals);
@ -134,8 +116,7 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
/**
* _gimp_image_set_color_profile:
* @image: The image.
* @num_bytes: Number of bytes in the color_profile array.
* @color_profile: (array length=num_bytes) (element-type guint8): The new serialized color profile.
* @color_profile: The new serialized color profile.
*
* Sets the image's color profile
*
@ -150,9 +131,8 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
* Since: 2.10
**/
gboolean
_gimp_image_set_color_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile)
_gimp_image_set_color_profile (GimpImage *image,
GBytes *color_profile)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -160,10 +140,8 @@ _gimp_image_set_color_profile (GimpImage *image,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_bytes,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, color_profile,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-set-color-profile",
@ -223,26 +201,22 @@ gimp_image_set_color_profile_from_file (GimpImage *image,
/**
* _gimp_image_get_simulation_profile:
* @image: The image.
* @num_bytes: (out): Number of bytes in the color_profile array.
*
* Returns the image's simulation color profile
*
* This procedure returns the image's simulation color profile, or NULL
* if the image has no simulation color profile assigned.
*
* Returns: (array length=num_bytes) (element-type guint8) (transfer full):
* The image's serialized simulation color profile.
* The returned value must be freed with g_free().
* Returns: (transfer full): The image's serialized simulation color profile.
*
* Since: 3.0
**/
guint8 *
_gimp_image_get_simulation_profile (GimpImage *image,
gint *num_bytes)
GBytes *
_gimp_image_get_simulation_profile (GimpImage *image)
{
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
GBytes *profile_data = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
@ -253,13 +227,8 @@ _gimp_image_get_simulation_profile (GimpImage *image,
args);
gimp_value_array_unref (args);
*num_bytes = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_bytes = GIMP_VALUES_GET_INT (return_vals, 1);
profile_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
profile_data = GIMP_VALUES_DUP_BYTES (return_vals, 1);
gimp_value_array_unref (return_vals);
@ -269,8 +238,7 @@ _gimp_image_get_simulation_profile (GimpImage *image,
/**
* _gimp_image_set_simulation_profile:
* @image: The image.
* @num_bytes: Number of bytes in the color_profile array.
* @color_profile: (array length=num_bytes) (element-type guint8): The new serialized simulation color profile.
* @color_profile: The new serialized simulation color profile.
*
* Sets the image's simulation color profile
*
@ -283,9 +251,8 @@ _gimp_image_get_simulation_profile (GimpImage *image,
* Since: 3.0
**/
gboolean
_gimp_image_set_simulation_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile)
_gimp_image_set_simulation_profile (GimpImage *image,
GBytes *color_profile)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -293,10 +260,8 @@ _gimp_image_set_simulation_profile (GimpImage *image,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_bytes,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, color_profile,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-set-simulation-profile",
@ -505,8 +470,7 @@ gimp_image_set_simulation_bpc (GimpImage *image,
/**
* _gimp_image_convert_color_profile:
* @image: The image.
* @num_bytes: Number of bytes in the color_profile array.
* @color_profile: (array length=num_bytes) (element-type guint8): The serialized color profile.
* @color_profile: The serialized color profile.
* @intent: Rendering intent.
* @bpc: Black point compensation.
*
@ -523,8 +487,7 @@ gimp_image_set_simulation_bpc (GimpImage *image,
**/
gboolean
_gimp_image_convert_color_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile,
GBytes *color_profile,
GimpColorRenderingIntent intent,
gboolean bpc)
{
@ -534,12 +497,10 @@ _gimp_image_convert_color_profile (GimpImage *image,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_bytes,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, color_profile,
GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
G_TYPE_BOOLEAN, bpc,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-convert-color-profile",

18
libgimp/gimpimagecolorprofile_pdb.h
View File

@ -32,20 +32,15 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
G_GNUC_INTERNAL guint8* _gimp_image_get_color_profile (GimpImage *image,
gint *num_bytes);
G_GNUC_INTERNAL guint8* _gimp_image_get_effective_color_profile (GimpImage *image,
gint *num_bytes);
G_GNUC_INTERNAL GBytes* _gimp_image_get_color_profile (GimpImage *image);
G_GNUC_INTERNAL GBytes* _gimp_image_get_effective_color_profile (GimpImage *image);
G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile);
GBytes *color_profile);
gboolean gimp_image_set_color_profile_from_file (GimpImage *image,
GFile *file);
G_GNUC_INTERNAL guint8* _gimp_image_get_simulation_profile (GimpImage *image,
gint *num_bytes);
G_GNUC_INTERNAL GBytes* _gimp_image_get_simulation_profile (GimpImage *image);
G_GNUC_INTERNAL gboolean _gimp_image_set_simulation_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile);
GBytes *color_profile);
gboolean gimp_image_set_simulation_profile_from_file (GimpImage *image,
GFile *file);
GimpColorRenderingIntent gimp_image_get_simulation_intent (GimpImage *image);
@ -55,8 +50,7 @@ gboolean gimp_image_get_simulation_bpc (GimpImage
gboolean gimp_image_set_simulation_bpc (GimpImage *image,
gboolean bpc);
G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile,
GBytes *color_profile,
GimpColorRenderingIntent intent,
gboolean bpc);
gboolean gimp_image_convert_color_profile_from_file (GimpImage *image,

14
libgimp/gimpimageconvert_pdb.c
View File

@ -173,8 +173,7 @@ gimp_image_convert_indexed (GimpImage *image,
* gimp_image_convert_set_dither_matrix:
* @width: Width of the matrix (0 to reset to default matrix).
* @height: Height of the matrix (0 to reset to default matrix).
* @matrix_length: The length of 'matrix'.
* @matrix: (array length=matrix_length) (element-type guint8): The matrix -- all values must be >= 1.
* @matrix: The matrix -- all values must be >= 1.
*
* Set dither matrix for conversion to indexed
*
@ -186,10 +185,9 @@ gimp_image_convert_indexed (GimpImage *image,
* Since: 2.4
**/
gboolean
gimp_image_convert_set_dither_matrix (gint width,
gint height,
gint matrix_length,
const guint8 *matrix)
gimp_image_convert_set_dither_matrix (gint width,
gint height,
GBytes *matrix)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -198,10 +196,8 @@ gimp_image_convert_set_dither_matrix (gint width,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_INT, width,
G_TYPE_INT, height,
G_TYPE_INT, matrix_length,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, matrix,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 3), matrix, matrix_length);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-convert-set-dither-matrix",

3
libgimp/gimpimageconvert_pdb.h
View File

@ -43,8 +43,7 @@ gboolean gimp_image_convert_indexed (GimpImage *image,
const gchar *palette);
gboolean gimp_image_convert_set_dither_matrix (gint width,
gint height,
gint matrix_length,
const guint8 *matrix);
GBytes *matrix);
gboolean gimp_image_convert_precision (GimpImage *image,
GimpPrecision precision);

10
libgimp/gimppattern_pdb.c
View File

@ -95,8 +95,7 @@ gimp_pattern_get_info (GimpPattern *pattern,
* @width: (out): The pattern width.
* @height: (out): The pattern height.
* @bpp: (out): The pattern bpp.
* @num_color_bytes: (out): Number of pattern bytes.
* @color_bytes: (out) (array length=num_color_bytes) (element-type guint8) (transfer full): The pattern data.
* @color_bytes: (out) (transfer full): The pattern data.
*
* Gets information about the pattern (including pixels).
*
@ -113,8 +112,7 @@ gimp_pattern_get_pixels (GimpPattern *pattern,
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes)
GBytes **color_bytes)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -132,7 +130,6 @@ gimp_pattern_get_pixels (GimpPattern *pattern,
*width = 0;
*height = 0;
*bpp = 0;
*num_color_bytes = 0;
*color_bytes = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
@ -142,8 +139,7 @@ gimp_pattern_get_pixels (GimpPattern *pattern,
*width = GIMP_VALUES_GET_INT (return_vals, 1);
*height = GIMP_VALUES_GET_INT (return_vals, 2);
*bpp = GIMP_VALUES_GET_INT (return_vals, 3);
*num_color_bytes = GIMP_VALUES_GET_INT (return_vals, 4);
*color_bytes = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5);
*color_bytes = GIMP_VALUES_DUP_BYTES (return_vals, 4);
}
gimp_value_array_unref (return_vals);

3
libgimp/gimppattern_pdb.h
View File

@ -40,8 +40,7 @@ gboolean gimp_pattern_get_pixels (GimpPattern *pattern,
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes);
GBytes **color_bytes);
gboolean gimp_pattern_id_is_valid (const gchar *id);

7
libgimp/gimppatternselectbutton.c
View File

@ -388,7 +388,8 @@ static _PreviewImage
gimp_pattern_select_button_get_pattern_image (GimpPatternSelectButton *self)
{
GimpPattern *pattern;
gint pixelels_size;
gsize pixelels_size;
GBytes *color_bytes;
_PreviewImage result;
g_debug ("%s", G_STRFUNC);
@ -399,8 +400,8 @@ gimp_pattern_select_button_get_pattern_image (GimpPatternSelectButton *self)
&result.width,
&result.height,
&result.bpp,
&pixelels_size, /* discarded. */
&result.pixelels);
&color_bytes);
result.pixelels = g_bytes_unref_to_data (color_bytes, &pixelels_size);
return result;
}

22
libgimp/gimppdb.c
View File

@ -606,15 +606,14 @@ gboolean
gimp_pdb_get_data (const gchar *identifier,
gpointer data)
{
gint size;
guint8 *hack;
GBytes *hack = NULL;
gboolean success;
success = _gimp_pdb_get_data (identifier, &size, &hack);
success = _gimp_pdb_get_data (identifier, &hack);
if (hack)
{
memcpy (data, (gconstpointer) hack, size * sizeof (guint8));
memcpy (data, g_bytes_get_data (hack, NULL), g_bytes_get_size (hack));
g_free (hack);
}
@ -642,8 +641,8 @@ gimp_pdb_get_data_size (const gchar *identifier)
/**
* gimp_pdb_set_data:
* @identifier: The identifier associated with data.
* @data: A byte array containing data.
* @bytes: The number of bytes in the data
* @data: (array length=data_len): A byte array containing data.
* @data_len: The number of bytes in the data
*
* Associates the specified identifier with the supplied data.
*
@ -656,9 +655,16 @@ gimp_pdb_get_data_size (const gchar *identifier)
gboolean
gimp_pdb_set_data (const gchar *identifier,
gconstpointer data,
guint32 bytes)
guint32 data_len)
{
return _gimp_pdb_set_data (identifier, bytes, data);
GBytes *bytes;
gboolean ret;
bytes = g_bytes_new_static (data, data_len);
ret = _gimp_pdb_set_data (identifier, bytes);
g_bytes_unref (bytes);
return ret;
}

2
libgimp/gimppdb.h
View File

@ -117,7 +117,7 @@ gboolean gimp_pdb_get_data (const gchar *identifier,
gint gimp_pdb_get_data_size (const gchar *identifier);
gboolean gimp_pdb_set_data (const gchar *identifier,
gconstpointer data,
guint32 bytes);
guint32 data_len);
G_END_DECLS

34
libgimp/gimppdb_pdb.c
View File

@ -613,8 +613,7 @@ _gimp_pdb_get_proc_menu_paths (const gchar *procedure_name)
* _gimp_pdb_set_proc_icon:
* @procedure_name: The procedure for which to install the icon.
* @icon_type: The type of the icon.
* @icon_data_length: The length of 'icon-data'.
* @icon_data: (array length=icon_data_length) (element-type guint8): The procedure's icon. The format depends on the 'icon_type' parameter.
* @icon_data: The procedure's icon. The format depends on the 'icon_type' parameter.
*
* Register an icon for a plug-in procedure.
*
@ -627,8 +626,7 @@ _gimp_pdb_get_proc_menu_paths (const gchar *procedure_name)
gboolean
_gimp_pdb_set_proc_icon (const gchar *procedure_name,
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data)
GBytes *icon_data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -637,10 +635,8 @@ _gimp_pdb_set_proc_icon (const gchar *procedure_name,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name,
GIMP_TYPE_ICON_TYPE, icon_type,
G_TYPE_INT, icon_data_length,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, icon_data,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 3), icon_data, icon_data_length);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-set-proc-icon",
@ -1179,8 +1175,7 @@ _gimp_pdb_set_batch_interpreter (const gchar *procedure_name,
/**
* _gimp_pdb_get_data:
* @identifier: The identifier associated with data.
* @bytes: (out): The number of bytes in the data.
* @data: (out) (array length=bytes) (element-type guint8) (transfer full): A byte array containing data.
* @data: (out) (transfer full): A byte array containing data.
*
* Returns data associated with the specified identifier.
*
@ -1193,8 +1188,7 @@ _gimp_pdb_set_batch_interpreter (const gchar *procedure_name,
**/
gboolean
_gimp_pdb_get_data (const gchar *identifier,
gint *bytes,
guint8 **data)
GBytes **data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -1209,16 +1203,12 @@ _gimp_pdb_get_data (const gchar *identifier,
args);
gimp_value_array_unref (args);
*bytes = 0;
*data = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
if (success)
{
*bytes = GIMP_VALUES_GET_INT (return_vals, 1);
*data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2);
}
*data = GIMP_VALUES_DUP_BYTES (return_vals, 1);
gimp_value_array_unref (return_vals);
@ -1264,8 +1254,7 @@ _gimp_pdb_get_data_size (const gchar *identifier)
/**
* _gimp_pdb_set_data:
* @identifier: The identifier associated with data.
* @bytes: The number of bytes in the data.
* @data: (array length=bytes) (element-type guint8): A byte array containing data.
* @data: A byte array containing data.
*
* Associates the specified identifier with the supplied data.
*
@ -1276,9 +1265,8 @@ _gimp_pdb_get_data_size (const gchar *identifier)
* Returns: TRUE on success.
**/
gboolean
_gimp_pdb_set_data (const gchar *identifier,
gint bytes,
const guint8 *data)
_gimp_pdb_set_data (const gchar *identifier,
GBytes *data)
{
GimpValueArray *args;
GimpValueArray *return_vals;
@ -1286,10 +1274,8 @@ _gimp_pdb_set_data (const gchar *identifier,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, identifier,
G_TYPE_INT, bytes,
GIMP_TYPE_UINT8_ARRAY, NULL,
G_TYPE_BYTES, data,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), data, bytes);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-set-data",

9
libgimp/gimppdb_pdb.h
View File

@ -64,8 +64,7 @@ G_GNUC_INTERNAL gboolean _gimp_pdb_add_proc_menu_path (const gcha
G_GNUC_INTERNAL gchar** _gimp_pdb_get_proc_menu_paths (const gchar *procedure_name);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_icon (const gchar *procedure_name,
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data);
GBytes *icon_data);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_documentation (const gchar *procedure_name,
const gchar *blurb,
const gchar *help,
@ -100,12 +99,10 @@ G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_thumbnail_loader (const gcha
G_GNUC_INTERNAL gboolean _gimp_pdb_set_batch_interpreter (const gchar *procedure_name,
const gchar *interpreter_name);
G_GNUC_INTERNAL gboolean _gimp_pdb_get_data (const gchar *identifier,
gint *bytes,
guint8 **data);
GBytes **data);
G_GNUC_INTERNAL gint _gimp_pdb_get_data_size (const gchar *identifier);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_data (const gchar *identifier,
gint bytes,
const guint8 *data);
GBytes *data);
G_END_DECLS

36
libgimp/gimpprocedure-params.h
View File

@ -344,34 +344,34 @@ G_BEGIN_DECLS
g_value_take_param (gimp_value_array_index (args, n), value)
/* uint8 array */
/* bytes */
#define GIMP_PROC_ARG_UINT8_ARRAY(procedure, name, nick, blurb, flags) \
#define GIMP_PROC_ARG_BYTES(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_uint8_array (name, nick, blurb,\
flags))
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
#define GIMP_PROC_AUX_ARG_UINT8_ARRAY(procedure, name, nick, blurb, flags) \
#define GIMP_PROC_AUX_ARG_BYTES(procedure, name, nick, blurb, flags) \
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_uint8_array (name, nick, blurb,\
flags))
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
#define GIMP_PROC_VAL_UINT8_ARRAY(procedure, name, nick, blurb, flags) \
#define GIMP_PROC_VAL_BYTES(procedure, name, nick, blurb, flags) \
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_uint8_array (name, nick, blurb,\
flags))
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
#define GIMP_VALUES_GET_UINT8_ARRAY(args, n) \
gimp_value_get_uint8_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_GET_BYTES(args, n) \
g_value_get_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_UINT8_ARRAY(args, n) \
gimp_value_dup_uint8_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_BYTES(args, n) \
g_value_dup_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_UINT8_ARRAY(args, n, value, length) \
gimp_value_set_uint8_array (gimp_value_array_index (args, n), value, length)
#define GIMP_VALUES_SET_BYTES(args, n, value, length) \
g_value_set_boxed (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_TAKE_UINT8_ARRAY(args, n, value, length) \
gimp_value_take_uint8_array (gimp_value_array_index (args, n), value, length)
#define GIMP_VALUES_TAKE_BYTES(args, n, value, length) \
g_value_take_boxed (gimp_value_array_index (args, n), value)
/* int32 array */

27
libgimp/gimpprocedure.c
View File

@ -314,6 +314,7 @@ gimp_procedure_install_icon (GimpProcedure *procedure)
GimpIconType icon_type;
guint8 *icon_data = NULL;
gsize icon_data_length = 0;
GBytes *icon_bytes = NULL;
icon_type = gimp_procedure_get_icon_type (procedure);
@ -323,7 +324,8 @@ gimp_procedure_install_icon (GimpProcedure *procedure)
{
icon_data = (guint8 *) gimp_procedure_get_icon_name (procedure);
if (icon_data)
icon_data_length = strlen ((gchar *) icon_data) + 1;
icon_bytes = g_bytes_new_static (icon_data,
strlen ((gchar *) icon_data) + 1);
}
break;
@ -332,9 +334,12 @@ gimp_procedure_install_icon (GimpProcedure *procedure)
GdkPixbuf *pixbuf = gimp_procedure_get_icon_pixbuf (procedure);
if (pixbuf)
gdk_pixbuf_save_to_buffer (pixbuf,
(gchar **) &icon_data, &icon_data_length,
"png", NULL, NULL);
{
gdk_pixbuf_save_to_buffer (pixbuf,
(gchar **) &icon_data, &icon_data_length,
"png", NULL, NULL);
icon_bytes = g_bytes_new_take (icon_data, icon_data_length);
}
}
break;
@ -346,6 +351,7 @@ gimp_procedure_install_icon (GimpProcedure *procedure)
{
icon_data = (guchar *) g_file_get_uri (file);
icon_data_length = strlen ((gchar *) icon_data) + 1;
icon_bytes = g_bytes_new_take (icon_data, icon_data_length);
}
}
break;
@ -353,18 +359,7 @@ gimp_procedure_install_icon (GimpProcedure *procedure)
if (icon_data)
_gimp_pdb_set_proc_icon (gimp_procedure_get_name (procedure),
icon_type, icon_data_length, icon_data);
switch (icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
break;
case GIMP_ICON_TYPE_PIXBUF:
case GIMP_ICON_TYPE_IMAGE_FILE:
g_free (icon_data);
break;
}
icon_type, icon_bytes);
}
static void

28
libgimp/gimpresourceselect.c
View File

@ -193,16 +193,10 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-len",
"Mask length",
"Length of brush mask data",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "mask-data",
"Mask data",
"The brush mask data",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
"Mask data",
"The brush mask data",
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_PALETTE))
{
@ -232,16 +226,10 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-len",
"Mask length",
"Length of pattern mask data",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "mask-data",
"Mask data",
"The pattern mask data",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
"Mask data",
"The pattern mask data",
G_PARAM_READWRITE);
}
else
{

31
libgimp/gimpzoompreview.c
View File

@ -519,8 +519,8 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
}
else
{
guchar *sel;
guchar *src;
GBytes *sel;
GBytes *src;
GimpSelection *selection;
gint w, h;
gint bpp;
@ -533,9 +533,6 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
selection = gimp_image_get_selection (image);
w = width;
h = height;
gimp_zoom_preview_get_source_area (preview,
&src_x, &src_y,
&src_width, &src_height);
@ -543,22 +540,24 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
src = gimp_drawable_get_sub_thumbnail_data (priv->drawable,
src_x, src_y,
src_width, src_height,
width, height,
&w, &h, &bpp);
gimp_drawable_get_offsets (priv->drawable, &offsx, &offsy);
sel = gimp_drawable_get_sub_thumbnail_data (GIMP_DRAWABLE (selection),
src_x + offsx, src_y + offsy,
src_width, src_height,
&width, &height, &bpp);
width, height,
&w, &h, &bpp);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (area),
0, 0, width, height,
gimp_drawable_type (priv->drawable),
src, width * gimp_drawable_get_bpp (priv->drawable),
g_bytes_get_data (src, NULL), width * gimp_drawable_get_bpp (priv->drawable),
buffer, rowstride,
sel, width);
g_bytes_get_data (sel, NULL), width);
g_free (sel);
g_free (src);
g_bytes_unref (sel);
g_bytes_unref (src);
}
}
@ -911,6 +910,8 @@ gimp_zoom_preview_get_source (GimpZoomPreview *preview,
gint src_y;
gint src_width;
gint src_height;
GBytes *src_bytes;
gsize src_bytes_size;
gimp_preview_get_size (gimp_preview, width, height);
@ -918,10 +919,12 @@ gimp_zoom_preview_get_source (GimpZoomPreview *preview,
&src_x, &src_y,
&src_width, &src_height);
return gimp_drawable_get_sub_thumbnail_data (drawable,
src_x, src_y,
src_width, src_height,
width, height, bpp);
src_bytes = gimp_drawable_get_sub_thumbnail_data (drawable,
src_x, src_y,
src_width, src_height,
*width, *height,
width, height, bpp);
return g_bytes_unref_to_data (src_bytes, &src_bytes_size);
}
else
{

8
libgimpbase/gimpbase.def
View File

@ -120,10 +120,8 @@ EXPORTS
gimp_param_spec_object_array
gimp_param_spec_parasite
gimp_param_spec_rgb_array
gimp_param_spec_uint8_array
gimp_param_spec_unit
gimp_param_spec_value_array
gimp_param_uint8_array_get_type
gimp_param_unit_get_type
gimp_param_value_array_get_type
gimp_parasite_compare
@ -184,7 +182,6 @@ EXPORTS
gimp_type_get_translation_domain
gimp_type_set_translation_context
gimp_type_set_translation_domain
gimp_uint8_array_get_type
gimp_unit_format_string
gimp_unit_get_abbreviation
gimp_unit_get_deletion_flag
@ -223,12 +220,10 @@ EXPORTS
gimp_value_dup_int32_array
gimp_value_dup_object_array
gimp_value_dup_rgb_array
gimp_value_dup_uint8_array
gimp_value_get_float_array
gimp_value_get_int32_array
gimp_value_get_object_array
gimp_value_get_rgb_array
gimp_value_get_uint8_array
gimp_value_set_float_array
gimp_value_set_int32_array
gimp_value_set_object_array
@ -237,13 +232,10 @@ EXPORTS
gimp_value_set_static_int32_array
gimp_value_set_static_object_array
gimp_value_set_static_rgb_array
gimp_value_set_static_uint8_array
gimp_value_set_uint8_array
gimp_value_take_float_array
gimp_value_take_int32_array
gimp_value_take_object_array
gimp_value_take_rgb_array
gimp_value_take_uint8_array
gimp_vectors_stroke_type_get_type
gimp_wire_clear_error
gimp_wire_destroy

167
libgimpbase/gimpparamspecs.c
View File

@ -254,173 +254,6 @@ gimp_value_take_array (GValue *value,
}
/*
* GIMP_TYPE_UINT8_ARRAY
*/
typedef GimpArray GimpUint8Array;
G_DEFINE_BOXED_TYPE (GimpUint8Array, gimp_uint8_array, gimp_array_copy, gimp_array_free)
/*
* GIMP_TYPE_PARAM_UINT8_ARRAY
*/
static void gimp_param_uint8_array_class_init (GParamSpecClass *klass);
static void gimp_param_uint8_array_init (GParamSpec *pspec);
GType
gimp_param_uint8_array_get_type (void)
{
static GType type = 0;
if (! type)
{
const GTypeInfo info =
{
sizeof (GParamSpecClass),
NULL, NULL,
(GClassInitFunc) gimp_param_uint8_array_class_init,
NULL, NULL,
sizeof (GimpParamSpecUInt8Array),
0,
(GInstanceInitFunc) gimp_param_uint8_array_init
};
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
"GimpParamUInt8Array", &info, 0);
}
return type;
}
static void
gimp_param_uint8_array_class_init (GParamSpecClass *klass)
{
klass->value_type = GIMP_TYPE_UINT8_ARRAY;
}
static void
gimp_param_uint8_array_init (GParamSpec *pspec)
{
}
/**
* gimp_param_spec_uint8_array:
* @name: Canonical name of the property specified.
* @nick: Nick name of the property specified.
* @blurb: Description of the property specified.
* @flags: Flags for the property specified.
*
* Creates a new #GimpParamSpecUInt8Array specifying a
* #GIMP_TYPE_UINT8_ARRAY property.
*
* See g_param_spec_internal() for details on property names.
*
* Returns: (transfer full): The newly created #GimpParamSpecUInt8Array.
*
* Since: 3.0
**/
GParamSpec *
gimp_param_spec_uint8_array (const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
{
GimpParamSpecArray *array_spec;
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_UINT8_ARRAY,
name, nick, blurb, flags);
return G_PARAM_SPEC (array_spec);
}
/**
* gimp_value_get_uint8_array:
* @value: A valid value of type %GIMP_TYPE_UINT8_ARRAY
*
* Gets the contents of a %GIMP_TYPE_UINT8_ARRAY #GValue
*
* Returns: (transfer none) (array): The contents of @value
*/
const guint8 *
gimp_value_get_uint8_array (const GValue *value)
{
g_return_val_if_fail (GIMP_VALUE_HOLDS_UINT8_ARRAY (value), NULL);
return gimp_value_get_array (value);
}
/**
* gimp_value_dup_uint8_array:
* @value: A valid value of type %GIMP_TYPE_UINT8_ARRAY
*
* Gets the contents of a %GIMP_TYPE_UINT8_ARRAY #GValue
*
* Returns: (transfer full) (array): The contents of @value
*/
guint8 *
gimp_value_dup_uint8_array (const GValue *value)
{
g_return_val_if_fail (GIMP_VALUE_HOLDS_UINT8_ARRAY (value), NULL);
return gimp_value_dup_array (value);
}
/**
* gimp_value_set_uint8_array:
* @value: A valid value of type %GIMP_TYPE_UINT8_ARRAY
* @data: (array length=length): A #guint8 array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data.
*/
void
gimp_value_set_uint8_array (GValue *value,
const guint8 *data,
gsize length)
{
g_return_if_fail (GIMP_VALUE_HOLDS_UINT8_ARRAY (value));
gimp_value_set_array (value, data, length);
}
/**
* gimp_value_set_static_uint8_array:
* @value: A valid value of type %GIMP_TYPE_UINT8_ARRAY
* @data: (array length=length): A #guint8 array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data, without copying the data.
*/
void
gimp_value_set_static_uint8_array (GValue *value,
const guint8 *data,
gsize length)
{
g_return_if_fail (GIMP_VALUE_HOLDS_UINT8_ARRAY (value));
gimp_value_set_static_array (value, data, length);
}
/**
* gimp_value_take_uint8_array:
* @value: A valid value of type %GIMP_TYPE_UINT8_ARRAY
* @data: (transfer full) (array length=length): A #guint8 array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data, and takes ownership of @data.
*/
void
gimp_value_take_uint8_array (GValue *value,
guint8 *data,
gsize length)
{
g_return_if_fail (GIMP_VALUE_HOLDS_UINT8_ARRAY (value));
gimp_value_take_array (value, data, length);
}
/*
* GIMP_TYPE_INT32_ARRAY
*/

45
libgimpbase/gimpparamspecs.h
View File

@ -128,51 +128,6 @@ GParamSpec * gimp_param_spec_array (const gchar *name,
GParamFlags flags);
/*
* GIMP_TYPE_UINT8_ARRAY
*/
#define GIMP_TYPE_UINT8_ARRAY (gimp_uint8_array_get_type ())
#define GIMP_VALUE_HOLDS_UINT8_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_UINT8_ARRAY))
GType gimp_uint8_array_get_type (void) G_GNUC_CONST;
/*
* GIMP_TYPE_PARAM_UINT8_ARRAY
*/
#define GIMP_TYPE_PARAM_UINT8_ARRAY (gimp_param_uint8_array_get_type ())
#define GIMP_PARAM_SPEC_UINT8_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_UINT8_ARRAY, GimpParamSpecUInt8Array))
#define GIMP_IS_PARAM_SPEC_UINT8_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_UINT8_ARRAY))
typedef struct _GimpParamSpecUInt8Array GimpParamSpecUInt8Array;
struct _GimpParamSpecUInt8Array
{
GimpParamSpecArray parent_instance;
};
GType gimp_param_uint8_array_get_type (void) G_GNUC_CONST;
GParamSpec * gimp_param_spec_uint8_array (const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags);
const guint8 * gimp_value_get_uint8_array (const GValue *value);
guint8 * gimp_value_dup_uint8_array (const GValue *value);
void gimp_value_set_uint8_array (GValue *value,
const guint8 *data,
gsize length);
void gimp_value_set_static_uint8_array (GValue *value,
const guint8 *data,
gsize length);
void gimp_value_take_uint8_array (GValue *value,
guint8 *data,
gsize length);
/*
* GIMP_TYPE_INT32_ARRAY
*/

2
libgimpbase/gimpparasite.h
View File

@ -75,7 +75,7 @@ GParamSpec * gimp_param_spec_parasite (const gchar *name,
* @name: the parasite name, USE A UNIQUE PREFIX
* @flags: the parasite flags, like save in XCF etc.
* @size: the parasite size in bytes
* @data: the parasite data, the owner os the parasite is responsible
* @data: (array length=size): the parasite data, the owner os the parasite is responsible
* for tracking byte order and internal structure
**/
struct _GimpParasite

40
libgimpbase/gimpprotocol.c
View File

@ -1638,6 +1638,26 @@ _gp_params_read (GIOChannel *channel,
}
break;
case GP_PARAM_TYPE_BYTES:
{
guint32 data_len;
guint8* data;
if (! _gimp_wire_read_int32 (channel, &data_len, 1, user_data))
goto cleanup;
data = g_new0 (guint8, data_len);
if (! _gimp_wire_read_int8 (channel, data, data_len, user_data))
{
g_free (data);
goto cleanup;
}
(*params)[i].data.d_bytes = g_bytes_new_take (data, data_len);
}
break;
case GP_PARAM_TYPE_STRV:
{
guint32 size;
@ -1803,6 +1823,22 @@ _gp_params_write (GIOChannel *channel,
return;
break;
case GP_PARAM_TYPE_BYTES:
{
const guint8 *bytes = NULL;
guint32 size = 0;
if (params[i].data.d_bytes)
{
bytes = g_bytes_get_data (params[i].data.d_bytes, (gsize *) &size);
}
if (! _gimp_wire_write_int32 (channel, &size, 1, user_data) ||
! _gimp_wire_write_int8 (channel, bytes, size, user_data))
return;
}
break;
case GP_PARAM_TYPE_STRV:
{
gint size;
@ -1901,6 +1937,10 @@ _gp_params_destroy (GPParam *params,
g_free (params[i].data.d_array.data);
break;
case GP_PARAM_TYPE_BYTES:
g_bytes_unref (params[i].data.d_bytes);
break;
case GP_PARAM_TYPE_STRV:
g_strfreev (params[i].data.d_strv);
break;

2
libgimpbase/gimpprotocol.h
View File

@ -66,6 +66,7 @@ typedef enum
GP_PARAM_TYPE_FLOAT,
GP_PARAM_TYPE_STRING,
GP_PARAM_TYPE_STRV,
GP_PARAM_TYPE_BYTES,
GP_PARAM_TYPE_FILE,
GP_PARAM_TYPE_COLOR,
GP_PARAM_TYPE_PARASITE,
@ -250,6 +251,7 @@ struct _GPParam
gdouble d_float;
gchar *d_string;
gchar **d_strv;
GBytes *d_bytes;
GimpRGB d_color;
GimpParasite d_parasite;
GPParamArray d_array;

14
libgimpconfig/gimpconfig-params.c
View File

@ -308,12 +308,7 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec)
}
else if (GIMP_IS_PARAM_SPEC_ARRAY (pspec))
{
if (GIMP_IS_PARAM_SPEC_UINT8_ARRAY (pspec))
{
copy = gimp_param_spec_uint8_array (name, nick, blurb,
flags);
}
else if (GIMP_IS_PARAM_SPEC_INT32_ARRAY (pspec))
if (GIMP_IS_PARAM_SPEC_INT32_ARRAY (pspec))
{
copy = gimp_param_spec_int32_array (name, nick, blurb,
flags);
@ -367,11 +362,10 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec)
{
GType value_type = G_PARAM_SPEC_VALUE_TYPE (pspec);
if (value_type == G_TYPE_STRV)
if (value_type == G_TYPE_BYTES ||
value_type == G_TYPE_STRV)
{
copy = g_param_spec_boxed (name, nick, blurb,
value_type,
flags);
copy = g_param_spec_boxed (name, nick, blurb, value_type, flags);
}
}

17
pdb/app.pl
View File

@ -604,14 +604,6 @@ gimp_param_spec_int32_array ("$name",
"$nick",
"$blurb",
$flags)
CODE
}
elsif ($pdbtype eq 'int8array') {
$pspec = <<CODE;
gimp_param_spec_uint8_array ("$name",
"$nick",
"$blurb",
$flags)
CODE
}
elsif ($pdbtype eq 'floatarray') {
@ -620,6 +612,15 @@ gimp_param_spec_float_array ("$name",
"$nick",
"$blurb",
$flags)
CODE
}
elsif ($pdbtype eq 'bytes') {
$pspec = <<CODE;
g_param_spec_boxed ("$name",
"$nick",
"$blurb",
G_TYPE_BYTES,
$flags)
CODE
}
elsif ($pdbtype eq 'strv') {

16
pdb/groups/brush.pdb
View File

@ -309,14 +309,12 @@ HELP
desc => 'The brush height' },
{ name => 'mask_bpp', type => 'int32',
desc => 'The brush mask bpp' },
{ name => 'mask_bytes', type => 'int8array',
desc => 'The brush mask data',
array => { desc => 'Length of brush mask data' } },
{ name => 'mask_bytes', type => 'bytes',
desc => 'The brush mask data' },
{ name => 'color_bpp', type => 'int32',
desc => 'The brush color bpp' },
{ name => 'color_bytes', type => 'int8array',
desc => 'The brush color data',
array => { desc => 'Length of brush color data' } }
{ name => 'color_bytes', type => 'bytes',
desc => 'The brush color data' }
);
%invoke = (
@ -326,6 +324,8 @@ HELP
GimpTempBuf *pixmap = gimp_brush_get_pixmap (brush);
const Babl *format;
gpointer data;
gsize num_mask_bytes;
gsize num_color_bytes;
format = gimp_babl_compat_u8_mask_format (
gimp_temp_buf_get_format (mask));
@ -336,7 +336,7 @@ HELP
mask_bpp = babl_format_get_bytes_per_pixel (format);
num_mask_bytes = gimp_temp_buf_get_height (mask) *
gimp_temp_buf_get_width (mask) * mask_bpp;
mask_bytes = g_memdup2 (data, num_mask_bytes);
mask_bytes = g_bytes_new (data, num_mask_bytes);
gimp_temp_buf_unlock (mask, data);
@ -350,7 +350,7 @@ HELP
num_color_bytes = gimp_temp_buf_get_height (pixmap) *
gimp_temp_buf_get_width (pixmap) *
color_bpp;
color_bytes = g_memdup2 (data, num_color_bytes);
color_bytes = g_bytes_new (data, num_color_bytes);
gimp_temp_buf_unlock (pixmap, data);
}

122
pdb/groups/drawable.pdb
View File

@ -630,105 +630,6 @@ CODE
);
}
sub drawable_get_pixel {
$blurb = 'Gets the value of the pixel at the specified coordinates.';
$help = <<'HELP';
This procedure gets the pixel value at the specified coordinates. The
'num_channels' argument must always be equal to the bytes-per-pixel value for
the specified drawable.
HELP
&std_pdb_misc;
$date = '1997';
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The drawable' },
{ name => 'x_coord', type => '0 <= int32',
desc => 'The x coordinate' },
{ name => 'y_coord', type => '0 <= int32',
desc => 'The y coordinate' }
);
@outargs = (
{ name => 'pixel', type => 'int8array',
desc => 'The pixel value',
array => { name => 'num_channels', no_validate => 1,
desc => 'The number of channels for the pixel' } }
);
%invoke = (
code => <<'CODE'
{
const Babl *format = gimp_drawable_get_format (drawable);
if (x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
y_coord < gimp_item_get_height (GIMP_ITEM (drawable)))
{
num_channels = babl_format_get_bytes_per_pixel (format);
pixel = g_new0 (guint8, num_channels);
gegl_buffer_sample (gimp_drawable_get_buffer (drawable),
x_coord, y_coord, NULL, pixel, format,
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
}
else
success = FALSE;
}
CODE
);
}
sub drawable_set_pixel {
$blurb = 'Sets the value of the pixel at the specified coordinates.';
$help = <<'HELP';
This procedure sets the pixel value at the specified coordinates. The
'num_channels' argument must always be equal to the bytes-per-pixel value for
the specified drawable. Note that this function is not undoable, you should
use it only on drawables you just created yourself.
HELP
&std_pdb_misc;
$date = '1997';
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The drawable' },
{ name => 'x_coord', type => '0 <= int32',
desc => 'The x coordinate' },
{ name => 'y_coord', type => '0 <= int32',
desc => 'The y coordinate' },
{ name => 'pixel', type => 'int8array',
desc => 'The pixel value',
array => { name => 'num_channels', no_validate => 1,
desc => 'The number of channels for the pixel' } }
);
%invoke = (
code => <<'CODE'
{
const Babl *format = gimp_drawable_get_format (drawable);
if (gimp_pdb_item_is_modifiable (GIMP_ITEM (drawable),
GIMP_PDB_ITEM_CONTENT, error) &&
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
y_coord < gimp_item_get_height (GIMP_ITEM (drawable)) &&
num_channels == babl_format_get_bytes_per_pixel (format))
{
gegl_buffer_set (gimp_drawable_get_buffer (drawable),
GEGL_RECTANGLE (x_coord, y_coord, 1, 1),
0, format, pixel, GEGL_AUTO_ROWSTRIDE);
}
else
success = FALSE;
}
CODE
);
}
sub drawable_thumbnail {
$blurb = 'Get a thumbnail of a drawable.';
@ -759,10 +660,8 @@ HELP
desc => 'The previews height' },
{ name => 'bpp', type => 'int32',
desc => 'The previews bpp' },
{ name => 'thumbnail_data', type => 'int8array',
desc => 'The thumbnail data',
array => { name => 'thumbnail_data_count',
desc => 'The number of bytes in thumbnail data' } }
{ name => 'thumbnail_data', type => 'bytes',
desc => 'The thumbnail data', }
);
%invoke = (
@ -796,9 +695,8 @@ HELP
actual_width = gimp_temp_buf_get_width (buf);
actual_height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}
@ -847,10 +745,8 @@ HELP
desc => 'The previews height' },
{ name => 'bpp', type => 'int32',
desc => 'The previews bpp' },
{ name => 'thumbnail_data', type => 'int8array',
desc => 'The thumbnail data',
array => { name => 'thumbnail_data_count',
desc => 'The number of bytes in thumbnail data' } }
{ name => 'thumbnail_data', type => 'bytes',
desc => 'The thumbnail data' }
);
%invoke = (
@ -878,9 +774,8 @@ HELP
width = gimp_temp_buf_get_width (buf);
height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}
@ -1028,7 +923,6 @@ CODE
drawable_merge_shadow
drawable_free_shadow
drawable_update
drawable_get_pixel drawable_set_pixel
drawable_fill
drawable_offset
drawable_thumbnail

11
pdb/groups/file.pdb
View File

@ -325,10 +325,8 @@ HELP
desc => 'The width of the thumbnail' },
{ name => 'height', type => 'int32',
desc => 'The height of the thumbnail' },
{ name => 'thumb_data', type => 'int8array',
desc => 'The thumbnail data',
array => { name => 'thumb_data_count',
desc => 'The number of bytes in thumbnail data' } }
{ name => 'thumb_data', type => 'bytes',
desc => 'The thumbnail data' }
);
%invoke = (
@ -340,9 +338,8 @@ HELP
{
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
thumb_data_count = 3 * width * height;
thumb_data = g_memdup2 (gdk_pixbuf_get_pixels (pixbuf),
thumb_data_count);
thumb_data = g_bytes_new (gdk_pixbuf_get_pixels (pixbuf),
3 * width * height);
g_object_unref (pixbuf);
}

35
pdb/groups/image.pdb
View File

@ -1511,18 +1511,19 @@ HELP
);
@outargs = (
{ name => 'colormap', type => 'int8array',
desc => "The image's colormap.",
array => { name => 'num_bytes',
desc => 'Number of bytes in the colormap array' } }
{ name => 'colormap', type => 'bytes',
desc => "The image's colormap." }
);
%invoke = (
headers => [ qw("core/gimpimage-colormap.h") ],
code => <<'CODE'
{
num_bytes = 3 * gimp_image_get_colormap_size (image);
colormap = gimp_image_get_colormap (image);
guchar *colormap_data;
colormap_data = gimp_image_get_colormap (image);
colormap = g_bytes_new_take (colormap_data,
gimp_image_get_colormap_size (image));
}
CODE
);
@ -1545,17 +1546,18 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'colormap', type => 'int8array',
desc => 'The new colormap values',
array => { name => 'num_bytes', type => '0 <= int32 <= 768',
desc => 'Number of bytes in the colormap array' } }
{ name => 'colormap', type => 'bytes',
desc => 'The new colormap values' }
);
%invoke = (
headers => [ qw("core/gimpimage-colormap.h") ],
code => <<'CODE'
{
gimp_image_set_colormap (image, colormap, num_bytes / 3, TRUE);
gimp_image_set_colormap (image,
g_bytes_get_data (colormap, NULL),
g_bytes_get_size (colormap) / 3,
TRUE);
}
CODE
);
@ -3035,10 +3037,8 @@ HELP
desc => 'The previews height' },
{ name => 'bpp', type => 'int32',
desc => 'The previews bpp' },
{ name => 'thumbnail_data', type => 'int8array',
desc => 'The thumbnail data',
array => { name => 'thumbnail_data_count',
desc => 'The number of bytes in thumbnail data' } }
{ name => 'thumbnail_data', type => 'bytes',
desc => 'The thumbnail data' }
);
%invoke = (
@ -3068,9 +3068,8 @@ HELP
actual_width = gimp_temp_buf_get_width (buf);
actual_height = gimp_temp_buf_get_height (buf);
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
thumbnail_data_count);
thumbnail_data = g_bytes_new (gimp_temp_buf_get_data (buf),
gimp_temp_buf_get_data_size (buf));
gimp_temp_buf_unref (buf);
}

57
pdb/groups/image_color_profile.pdb
View File

@ -34,10 +34,8 @@ HELP
);
@outargs = (
{ name => 'profile_data', type => 'int8array',
desc => "The image's serialized color profile.",
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } }
{ name => 'profile_data', type => 'bytes',
desc => "The image's serialized color profile." }
);
%invoke = (
@ -54,8 +52,7 @@ HELP
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
CODE
@ -82,10 +79,8 @@ HELP
);
@outargs = (
{ name => 'profile_data', type => 'int8array',
desc => "The image's serialized color profile.",
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } }
{ name => 'profile_data', type => 'bytes',
desc => "The image's serialized color profile." }
);
%invoke = (
@ -102,8 +97,7 @@ HELP
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
CODE
@ -128,10 +122,8 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'color_profile', type => 'int8array',
desc => 'The new serialized color profile',
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } }
{ name => 'color_profile', type => 'bytes',
desc => 'The new serialized color profile' }
);
%invoke = (
@ -141,8 +133,8 @@ HELP
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)
@ -231,10 +223,8 @@ HELP
);
@outargs = (
{ name => 'profile_data', type => 'int8array',
desc => "The image's serialized simulation color profile.",
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } }
{ name => 'profile_data', type => 'bytes',
desc => "The image's serialized simulation color profile." }
);
%invoke = (
@ -251,8 +241,7 @@ HELP
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup2 (data, length);
num_bytes = length;
profile_data = g_bytes_new (data, length);
}
}
CODE
@ -274,10 +263,8 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'color_profile', type => 'int8array',
desc => 'The new serialized simulation color profile',
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } }
{ name => 'color_profile', type => 'bytes',
desc => 'The new serialized simulation color profile'}
);
%invoke = (
@ -287,8 +274,8 @@ HELP
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)
@ -479,10 +466,8 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'color_profile', type => 'int8array',
desc => 'The serialized color profile',
array => { name => 'num_bytes',
desc => 'Number of bytes in the color_profile array' } },
{ name => 'color_profile', type => 'bytes',
desc => 'The serialized color profile' },
{ name => 'intent', type => 'enum GimpColorRenderingIntent',
desc => 'Rendering intent' },
{ name => 'bpc', type => 'boolean',
@ -496,8 +481,8 @@ HELP
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
profile = gimp_color_profile_new_from_icc_profile (g_bytes_get_data (color_profile, NULL),
g_bytes_get_size (color_profile),
error);
if (profile)

12
pdb/groups/image_convert.pdb
View File

@ -192,19 +192,17 @@ HELP
desc => 'Width of the matrix (0 to reset to default matrix)' },
{ name => 'height', type => 'int32',
desc => 'Height of the matrix (0 to reset to default matrix)' },
{ name => 'matrix', type => 'int8array',
desc => 'The matrix -- all values must be >= 1',
array => { name => 'matrix_length', type => '1 <= int32 <= 1024',
desc => "The length of 'matrix'" }
},
{ name => 'matrix', type => 'bytes',
desc => 'The matrix -- all values must be >= 1' },
);
%invoke = (
code => <<'CODE'
{
if (width == 0 || height == 0 || matrix_length == width * height)
if (width == 0 || height == 0 || g_bytes_get_size (matrix) == width * height)
{
gimp_image_convert_indexed_set_dither_matrix (matrix, width, height);
gimp_image_convert_indexed_set_dither_matrix (g_bytes_get_data (matrix, NULL),
width, height);
}
else
{

8
pdb/groups/pattern.pdb
View File

@ -87,9 +87,8 @@ HELP
desc => "The pattern height" },
{ name => 'bpp', type => 'int32',
desc => "The pattern bpp" },
{ name => 'color_bytes', type => 'int8array',
desc => 'The pattern data.',
array => { desc => 'Number of pattern bytes' } }
{ name => 'color_bytes', type => 'bytes',
desc => 'The pattern data.' }
);
%invoke = (
@ -106,8 +105,7 @@ HELP
width = gimp_temp_buf_get_width (pattern->mask);
height = gimp_temp_buf_get_height (pattern->mask);
bpp = babl_format_get_bytes_per_pixel (format);
num_color_bytes = gimp_temp_buf_get_data_size (pattern->mask);
color_bytes = g_memdup2 (data, num_color_bytes);
color_bytes = g_bytes_new (data, gimp_temp_buf_get_data_size (pattern->mask));
gimp_temp_buf_unlock (pattern->mask, data);
}

28
pdb/groups/pdb.pdb
View File

@ -656,11 +656,9 @@ HELP
desc => 'The procedure for which to install the icon' },
{ name => 'icon_type', type => 'enum GimpIconType',
desc => 'The type of the icon' },
{ name => 'icon_data', type => 'int8array',
{ name => 'icon_data', type => 'bytes',
desc => "The procedure's icon. The format depends on the
'icon_type' parameter",
array => { name => 'icon_data_length', type => '1 <= int32',
desc => "The length of 'icon-data'" } }
'icon_type' parameter", }
);
%invoke = (
@ -673,7 +671,8 @@ HELP
{
success = gimp_plug_in_set_proc_icon (plug_in, procedure_name,
icon_type,
icon_data, icon_data_length,
g_bytes_get_data (icon_data, NULL),
g_bytes_get_size (icon_data),
error);
}
else
@ -1215,10 +1214,8 @@ HELP
);
@outargs = (
{ name => 'data', type => 'int8array', void_ret => 1,
desc => 'A byte array containing data',
array => { name => 'bytes', type => '1 <= int32',
desc => 'The number of bytes in the data' } }
{ name => 'data', type => 'bytes', void_ret => 1,
desc => 'A byte array containing data' }
);
%invoke = (
@ -1227,12 +1224,13 @@ HELP
if (gimp_is_canonical_identifier (identifier))
{
const guint8 *orig_data;
gint bytes;
orig_data = gimp_plug_in_manager_get_data (gimp->plug_in_manager,
identifier, &bytes);
if (orig_data)
data = g_memdup2 (orig_data, bytes);
data = g_bytes_new (orig_data, bytes);
else
success = FALSE;
}
@ -1308,10 +1306,8 @@ HELP
@inargs = (
{ name => 'identifier', type => 'string', non_empty => 1,
desc => 'The identifier associated with data' },
{ name => 'data', type => 'int8array',
desc => 'A byte array containing data',
array => { name => 'bytes', type => '1 <= int32',
desc => 'The number of bytes in the data' } }
{ name => 'data', type => 'bytes',
desc => 'A byte array containing data' }
);
%invoke = (
@ -1320,7 +1316,9 @@ HELP
if (gimp_is_canonical_identifier (identifier))
{
gimp_plug_in_manager_set_data (gimp->plug_in_manager,
identifier, bytes, data);
identifier,
g_bytes_get_size (data),
g_bytes_get_data (data, NULL));
}
else
{

24
pdb/pdb.pl
View File

@ -70,6 +70,17 @@ package Gimp::CodeGen::pdb;
set_value_func => 'g_value_set_boxed ($value, $var)',
take_value_func => 'g_value_take_boxed ($value, $var)' },
bytes => { name => 'BYTES',
gtype => 'G_TYPE_BYTES',
type => 'GBytes *',
const_type => 'GBytes *',
init_value => 'NULL',
out_annotate => '(transfer full)',
get_value_func => '$var = g_value_get_boxed ($value)',
dup_value_func => '$var = GIMP_VALUES_DUP_BYTES ($value)',
set_value_func => 'g_value_set_boxed ($value, $var)',
take_value_func => 'g_value_take_boxed ($value, $var)' },
int32array => { name => 'INT32ARRAY',
gtype => 'GIMP_TYPE_INT32_ARRAY',
type => 'gint32 *',
@ -83,19 +94,6 @@ package Gimp::CodeGen::pdb;
set_value_func => 'gimp_value_set_int32_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_int32_array ($value, $var, $var_len)' },
int8array => { name => 'INT8ARRAY',
gtype => 'GIMP_TYPE_UINT8_ARRAY',
type => 'guint8 *',
const_type => 'const guint8 *',
array => 1,
init_value => 'NULL',
in_annotate => '(element-type guint8)',
out_annotate => '(element-type guint8) (transfer full)',
get_value_func => '$var = gimp_value_get_uint8_array ($value)',
dup_value_func => '$var = GIMP_VALUES_DUP_UINT8_ARRAY ($value)',
set_value_func => 'gimp_value_set_uint8_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_uint8_array ($value, $var, $var_len)' },
floatarray => { name => 'FLOATARRAY',
gtype => 'GIMP_TYPE_FLOAT_ARRAY',
type => 'gdouble *',

2
plug-ins/common/animation-optimize.c
View File

@ -561,7 +561,7 @@ do_optimizations (GimpRunMode run_mode,
if (imagetype == GIMP_INDEXED)
{
palette = gimp_image_get_colormap (image, &ncolors);
palette = gimp_image_get_colormap (image, NULL, &ncolors);
gimp_image_set_colormap (new_image, palette, ncolors);
}

26
plug-ins/common/blinds.c
View File

@ -354,14 +354,14 @@ blinds_dialog (GimpProcedure *procedure,
}
static void
blindsapply (GObject *config,
guchar *srow,
guchar *drow,
gint width,
gint bpp,
guchar *bg)
blindsapply (GObject *config,
const guchar *srow,
guchar *drow,
gint width,
gint bpp,
guchar *bg)
{
guchar *src;
const guchar *src;
guchar *dst;
gint i,j,k;
gdouble ang;
@ -473,9 +473,10 @@ dialog_update_preview (GtkWidget *widget,
GimpPreview *preview = GIMP_PREVIEW (widget);
GimpDrawable *drawable = g_object_get_data (config, "drawable");
gint y;
guchar *p;
const guchar *p;
guchar *buffer;
guchar *cache;
GBytes *cache;
const guchar *cache_start;
GimpRGB background;
guchar bg[4];
gint width;
@ -491,8 +492,9 @@ dialog_update_preview (GtkWidget *widget,
gimp_preview_get_size (preview, &width, &height);
cache = gimp_drawable_get_thumbnail_data (drawable,
width, height,
&width, &height, &bpp);
p = cache;
p = cache_start = g_bytes_get_data (cache, NULL);
gimp_context_get_background (&background);
@ -569,7 +571,7 @@ dialog_update_preview (GtkWidget *widget,
else
{
/* Draw line from src */
p = cache +
p = cache_start +
(width * bpp * (dr[y] - 1));
}
memcpy (buffer + y * width * bpp,
@ -583,7 +585,7 @@ dialog_update_preview (GtkWidget *widget,
gimp_preview_draw_buffer (preview, buffer, width * bpp);
g_free (buffer);
g_free (cache);
g_bytes_unref (cache);
}
/* STEP tells us how many rows/columns to gulp down in one go... */

30
plug-ins/common/colormap-remap.c
View File

@ -200,16 +200,10 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>",
"June 2006");
GIMP_PROC_ARG_INT (procedure, "num-colors",
"Num colors",
"Length of 'map' argument",
1, 256, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "map",
"Map",
"Remap array for the colormap",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "map",
"Map",
"Remap array for the colormap",
G_PARAM_READWRITE);
}
else if (! strcmp (name, PLUG_IN_PROC_SWAP))
{
@ -321,13 +315,13 @@ remap_run (GimpProcedure *procedure,
if (strcmp (gimp_procedure_get_name (procedure),
PLUG_IN_PROC_REMAP) == 0)
{
gint n_col_args;
GBytes *col_args_bytes;
const guchar *col_args;
g_free (gimp_image_get_colormap (image, &remap->n_cols));
g_free (gimp_image_get_colormap (image, NULL, &remap->n_cols));
n_col_args = GIMP_VALUES_GET_INT (args, 0);
col_args = GIMP_VALUES_GET_UINT8_ARRAY (args, 1);
col_args_bytes = GIMP_VALUES_GET_BYTES (args, 0);
col_args = g_bytes_get_data (col_args_bytes, NULL);
switch (run_mode)
{
@ -343,7 +337,7 @@ remap_run (GimpProcedure *procedure,
break;
case GIMP_RUN_NONINTERACTIVE:
if (remap->n_cols != n_col_args)
if (remap->n_cols != g_bytes_get_size (col_args_bytes))
return gimp_procedure_new_return_values (procedure,
GIMP_PDB_CALLING_ERROR,
NULL);
@ -381,7 +375,7 @@ remap_run (GimpProcedure *procedure,
GIMP_PDB_CALLING_ERROR,
NULL);
g_free (gimp_image_get_colormap (image, &n_cols));
g_free (gimp_image_get_colormap (image, NULL, &n_cols));
if (index1 >= n_cols || index2 >= n_cols)
return gimp_procedure_new_return_values (procedure,
@ -419,7 +413,7 @@ real_remap (GimpImage *image,
gboolean valid[256];
gint i;
cmap = gimp_image_get_colormap (image, &ncols);
cmap = gimp_image_get_colormap (image, NULL, &ncols);
g_return_val_if_fail (cmap != NULL, FALSE);
g_return_val_if_fail (ncols > 0, FALSE);
@ -725,7 +719,7 @@ remap_dialog (GimpImage *image,
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
cmap = gimp_image_get_colormap (image, &ncols);
cmap = gimp_image_get_colormap (image, NULL, &ncols);
g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE);

72
plug-ins/common/curve-bend.c
View File

@ -368,8 +368,7 @@ static void p_copy_points (BenderDialog *cd,
const gdouble *floatarray);
static void p_copy_yval (BenderDialog *cd,
int outline,
int argc,
const guint8 *int8array);
GBytes *bytes);
static int p_save_pointfile (BenderDialog *cd,
const gchar *filename);
@ -537,29 +536,17 @@ bender_create_procedure (GimpPlugIn *plug_in,
"{ 0.0 <= y <= 1.0 or -1 for unused point }",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-upper-val-y",
"Argc upper val Y",
"Argc upper val Y",
256, 256, 256,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "upper-val-y",
"Upper val Y",
"Array of 256 y freehand coords "
"{ 0 <= y <= 255 }",
G_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "upper-val-y",
"Upper val Y",
"Array of 256 y freehand coords "
"{ 0 <= y <= 255 }",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-lower-val-y",
"Argc lower val Y",
"Argc lower val Y",
256, 256, 256,
G_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "lower-val-y",
"Lower val Y",
"Array of 256 y freehand coords "
"{ 0 <= y <= 255 }",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "lower-val-y",
"Lower val Y",
"Array of 256 y freehand coords "
"{ 0 <= y <= 255 }",
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "bent-layer",
"Bent layer",
@ -767,11 +754,9 @@ bender_run (GimpProcedure *procedure,
GIMP_VALUES_GET_FLOAT_ARRAY (args, 12));
p_copy_yval (cd, OUTLINE_UPPER,
GIMP_VALUES_GET_INT (args, 13),
GIMP_VALUES_GET_UINT8_ARRAY (args, 14));
GIMP_VALUES_GET_BYTES (args, 13));
p_copy_yval (cd, OUTLINE_LOWER,
GIMP_VALUES_GET_INT (args, 15),
GIMP_VALUES_GET_UINT8_ARRAY (args, 16));
GIMP_VALUES_GET_BYTES (args, 14));
break;
case GIMP_RUN_WITH_LAST_VALS:
@ -1094,25 +1079,22 @@ p_copy_points (BenderDialog *cd,
static void
p_copy_yval (BenderDialog *cd,
int outline,
int argc,
const guint8 *int8array)
GBytes *bytes)
{
int j;
guchar fill;
const guint8 *array = g_bytes_get_data (bytes, NULL);
guchar fill = MIDDLE;
fill = MIDDLE;
for (j = 0; j < 256; j++)
{
if (j < argc)
{
fill = cd->curve[outline][j] = int8array[j];
}
else
{
cd->curve[outline][j] = fill;
}
}
for (int j = 0; j < 256; j++)
{
if (j < g_bytes_get_size (bytes))
{
fill = cd->curve[outline][j] = array[j];
}
else
{
cd->curve[outline][j] = fill;
}
}
}
/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */

2
plug-ins/common/file-cel.c
View File

@ -865,7 +865,7 @@ save_image (GFile *file,
/* Work out whether to save as 8bit or 4bit */
if (bpp < 32)
{
g_free (gimp_image_get_colormap (image, &colors));
g_free (gimp_image_get_colormap (image, NULL, &colors));
if (colors > 15)
{

2
plug-ins/common/file-gif-save.c
View File

@ -857,7 +857,7 @@ save_image (GFile *file,
case GIMP_INDEXEDA_IMAGE:
is_gif89 = TRUE;
case GIMP_INDEXED_IMAGE:
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
gimp_context_get_background (&background);
gimp_rgb_get_uchar (&background, &bgred, &bggreen, &bgblue);

24
plug-ins/common/file-gih.c
View File

@ -238,16 +238,10 @@ gih_create_procedure (GimpPlugIn *plug_in,
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "dimension",
"Dimension",
"Dimension of the brush pipe",
1, 4, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_UINT8_ARRAY (procedure, "rank",
"Rank",
"Ranks of the dimensions",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "rank",
"Rank",
"Ranks of the dimensions",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "dimension-2",
"Dimension 2",
@ -280,6 +274,7 @@ gih_save (GimpProcedure *procedure,
GimpImage *orig_image;
GError *error = NULL;
gint i;
GBytes *rank_bytes;
orig_image = image;
@ -402,17 +397,18 @@ gih_save (GimpProcedure *procedure,
gihparams.cellheight = GIMP_VALUES_GET_INT (args, 3);
gihparams.cols = GIMP_VALUES_GET_INT (args, 4);
gihparams.rows = GIMP_VALUES_GET_INT (args, 5);
gihparams.dim = GIMP_VALUES_GET_INT (args, 6);
rank_bytes = GIMP_VALUES_GET_BYTES (args, 6);
gihparams.dim = g_bytes_get_size (rank_bytes);
gihparams.ncells = 1;
if (GIMP_VALUES_GET_INT (args, 8) != gihparams.dim)
if (GIMP_VALUES_GET_INT (args, 7) != gihparams.dim)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
const guint8 *rank = GIMP_VALUES_GET_UINT8_ARRAY (args, 7);
const gchar **sel = GIMP_VALUES_GET_STRV (args, 9);
const guint8 *rank = g_bytes_get_data (rank_bytes, NULL);
const gchar **sel = GIMP_VALUES_GET_STRV (args, 8);
for (i = 0; i < gihparams.dim; i++)
{

2
plug-ins/common/file-header.c
View File

@ -340,7 +340,7 @@ save_image (GFile *file,
}
/* save colormap */
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
if (! print (output, error,
"static unsigned char header_data_cmap[256][3] = {") ||

6
plug-ins/common/file-mng.c
View File

@ -660,7 +660,7 @@ respin_cmap (png_structp pp,
gint transparent;
gint cols, rows;
before = gimp_image_get_colormap (image, &colors);
before = gimp_image_get_colormap (image, NULL, &colors);
/* Make sure there is something in the colormap */
if (colors == 0)
@ -1032,7 +1032,7 @@ mng_save_image (GFile *file,
guchar *palette;
gint numcolors;
palette = gimp_image_get_colormap (image, &numcolors);
palette = gimp_image_get_colormap (image, NULL, &numcolors);
if ((numcolors != 0) &&
(mng_putchunk_plte_wrapper (handle, numcolors,
@ -1284,7 +1284,7 @@ mng_save_image (GFile *file,
mngg.has_plte = TRUE;
mngg.palette = (png_colorp)
gimp_image_get_colormap (image, &mngg.num_palette);
gimp_image_get_colormap (image, NULL, &mngg.num_palette);
bit_depth = get_bit_depth_for_palette (mngg.num_palette);
break;

3
plug-ins/common/file-pcx.c
View File

@ -1121,7 +1121,8 @@ save_image (GFile *file,
switch (drawable_type)
{
case GIMP_INDEXED_IMAGE:
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
if (colors > 16)
{
pcx_header.bpp = 8;

3
plug-ins/common/file-png.c
View File

@ -1606,6 +1606,7 @@ save_image (GFile *file,
file_format = gimp_drawable_get_format (drawable);
pngg.has_plte = TRUE;
pngg.palette = (png_colorp) gimp_image_get_colormap (image,
NULL,
&pngg.num_palette);
if (optimize_palette)
bit_depth = get_bit_depth_for_palette (pngg.num_palette);
@ -2185,7 +2186,7 @@ respin_cmap (png_structp pp,
gint colors;
guchar *before;
before = gimp_image_get_colormap (image, &colors);
before = gimp_image_get_colormap (image, NULL, &colors);
buffer = gimp_drawable_get_buffer (drawable);
/* Make sure there is something in the colormap.

2
plug-ins/common/file-pnm.c
View File

@ -1820,7 +1820,7 @@ save_image (GFile *file,
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
if (file_type == FILE_TYPE_PBM)
{

7
plug-ins/common/file-ps.c
View File

@ -2719,6 +2719,7 @@ save_ps_preview (GOutputStream *output,
case GIMP_INDEXED_IMAGE:
cmap = gimp_image_get_colormap (gimp_item_get_image (GIMP_ITEM (drawable)),
NULL,
&ncols);
format = gimp_drawable_get_format (drawable);
break;
@ -3032,7 +3033,7 @@ save_bw (GOutputStream *output,
"level", &level2,
NULL);
cmap = gimp_image_get_colormap (image, &ncols);
cmap = gimp_image_get_colormap (image, NULL, &ncols);
buffer = gimp_drawable_get_buffer (drawable);
format = gimp_drawable_get_format (drawable);
@ -3221,7 +3222,7 @@ save_index (GOutputStream *output,
"level", &level2,
NULL);
cmap = cmap_start = gimp_image_get_colormap (image, &ncols);
cmap = cmap_start = gimp_image_get_colormap (image, NULL, &ncols);
ct = coltab;
bw = 1;
@ -4029,4 +4030,4 @@ resolution_change_callback (GtkWidget *adjustment,
NULL);
return TRUE;
}
}

2
plug-ins/common/file-raw-data.c
View File

@ -1324,7 +1324,7 @@ save_image (GFile *file,
g_return_val_if_fail (bpc * n_components == bpp, FALSE);
if (gimp_drawable_is_indexed (drawable))
cmap = gimp_image_get_colormap (image, &palsize);
cmap = gimp_image_get_colormap (image, NULL, &palsize);
width = gegl_buffer_get_width (buffer);
height = gegl_buffer_get_height (buffer);

2
plug-ins/common/file-sunras.c
View File

@ -1529,7 +1529,7 @@ save_index (FILE *ofp,
}
else
{
cmap = gimp_image_get_colormap (image, &ncols);
cmap = gimp_image_get_colormap (image, NULL, &ncols);
for (j = 0; j < ncols; j++)
{

4
plug-ins/common/file-tga.c
View File

@ -1244,7 +1244,7 @@ save_image (GFile *file,
if (dtype == GIMP_INDEXED_IMAGE)
{
gimp_cmap = gimp_image_get_colormap (image, &num_colors);
gimp_cmap = gimp_image_get_colormap (image, NULL, &num_colors);
header[1] = 1; /* cmap type */
header[2] = rle ? 9 : 1;
@ -1255,7 +1255,7 @@ save_image (GFile *file,
}
else if (dtype == GIMP_INDEXEDA_IMAGE)
{
gimp_cmap = gimp_image_get_colormap (image, &num_colors);
gimp_cmap = gimp_image_get_colormap (image, NULL, &num_colors);
header[1] = 1; /* cmap type */
header[2] = rle ? 9 : 1;

2
plug-ins/common/file-xbm.c
View File

@ -1007,7 +1007,7 @@ save_image (GFile *file,
g_printerr ("%s: save_image '%s'\n", G_STRFUNC, prefix);
#endif
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
if (! gimp_drawable_is_indexed (drawable) || colors > 2)
{

2
plug-ins/common/file-xpm.c
View File

@ -790,7 +790,7 @@ save_image (GFile *file,
if (indexed)
{
guchar *cmap = gimp_image_get_colormap (image, &ncolors);
guchar *cmap = gimp_image_get_colormap (image, NULL, &ncolors);
guchar *c;
c = cmap;

2
plug-ins/common/file-xwd.c
View File

@ -2422,7 +2422,7 @@ save_index (GOutputStream *output,
else
{
vclass = 3;
cmap = gimp_image_get_colormap (image, &ncolors);
cmap = gimp_image_get_colormap (image, NULL, &ncolors);
for (j = 0; j < ncolors; j++)
{

2
plug-ins/common/grid.c
View File

@ -463,7 +463,7 @@ grid (GimpImage *image,
break;
case GIMP_INDEXED:
cmap = gimp_image_get_colormap (image, &ncolors);
cmap = gimp_image_get_colormap (image, NULL, &ncolors);
hcolor[0] = best_cmap_match (cmap, ncolors, &grid_cfg.hcolor);
vcolor[0] = best_cmap_match (cmap, ncolors, &grid_cfg.vcolor);

11
plug-ins/common/jigsaw.c
View File

@ -524,7 +524,7 @@ jigsaw (GObject *config,
gint width;
gint height;
gint bytes;
gint buffer_size;
gsize buffer_size;
gint x;
gint y;
gint blend_lines;
@ -537,10 +537,13 @@ jigsaw (GObject *config,
if (preview)
{
GBytes *buffer_bytes;
gimp_preview_get_size (preview, &width, &height);
buffer = gimp_drawable_get_thumbnail_data (drawable,
&width, &height, &bytes);
buffer_size = bytes * width * height;
buffer_bytes = gimp_drawable_get_thumbnail_data (drawable,
width, height,
&width, &height, &bytes);
buffer = g_bytes_unref_to_data (buffer_bytes, &buffer_size);
}
else
{

2
plug-ins/common/tile.c
View File

@ -397,7 +397,7 @@ tile (GimpImage *image,
guchar *cmap;
gint ncols;
cmap = gimp_image_get_colormap (image, &ncols);
cmap = gimp_image_get_colormap (image, NULL, &ncols);
gimp_image_set_colormap (*new_image, cmap, ncols);
g_free (cmap);
}

2
plug-ins/file-bmp/bmp-save.c
View File

@ -238,7 +238,7 @@ save_image (GFile *file,
case GIMP_INDEXED_IMAGE:
format = gimp_drawable_get_format (drawable);
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
MapSize = 4 * colors;
if (drawable_type == GIMP_INDEXEDA_IMAGE)

6
plug-ins/file-dds/ddswrite.c
View File

@ -911,7 +911,7 @@ write_layer (FILE *fp,
if (basetype == GIMP_INDEXED)
{
palette = gimp_image_get_colormap (image, &colors);
palette = gimp_image_get_colormap (image, NULL, &colors);
if (type == GIMP_INDEXEDA_IMAGE)
{
@ -1238,7 +1238,7 @@ write_volume_mipmaps (FILE *fp,
format = babl_format ("R'G'B'A u8");
if (gimp_image_get_base_type (image) == GIMP_INDEXED)
palette = gimp_image_get_colormap (image, &colors);
palette = gimp_image_get_colormap (image, NULL, &colors);
offset = 0;
for (i = 0, list = layers;
@ -1691,7 +1691,7 @@ write_image (FILE *fp,
(pixel_format == DDS_FORMAT_DEFAULT) &&
(compression == DDS_COMPRESS_NONE))
{
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
for (i = 0; i < colors; ++i)
{

2
plug-ins/file-fli/fli-gimp.c
View File

@ -747,7 +747,7 @@ save_image (GFile *file,
case GIMP_INDEXED:
max = MAXDIFF;
bg = 0;
cmap = gimp_image_get_colormap (image, &colors);
cmap = gimp_image_get_colormap (image, NULL, &colors);
for (i = 0; i < MIN (colors, 256); i++)
{
cm[i*3+0] = cmap[i*3+0];

8
plug-ins/file-ico/ico-dialog.c
View File

@ -370,7 +370,7 @@ ico_dialog_update_icon_preview (GtkWidget *dialog,
if (gimp_drawable_is_indexed (layer))
{
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
@ -403,7 +403,7 @@ ico_dialog_update_icon_preview (GtkWidget *dialog,
GIMP_CONVERT_PALETTE_GENERATE,
1 << bpp, TRUE, FALSE, "dummy");
cmap = gimp_image_get_colormap (tmp_image, &num_colors);
cmap = gimp_image_get_colormap (tmp_image, NULL, &num_colors);
if (num_colors == (1 << bpp) &&
! ico_cmap_contains_black (cmap, num_colors))
@ -414,7 +414,7 @@ ico_dialog_update_icon_preview (GtkWidget *dialog,
if (gimp_drawable_is_indexed (layer))
{
g_free (cmap);
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
}
else if (gimp_drawable_is_gray (layer))
@ -470,7 +470,7 @@ ico_dialog_update_icon_preview (GtkWidget *dialog,
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}

8
plug-ins/file-ico/ico-save.c
View File

@ -737,7 +737,7 @@ ico_image_get_reduced_buf (GimpDrawable *layer,
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
@ -768,7 +768,7 @@ ico_image_get_reduced_buf (GimpDrawable *layer,
GIMP_CONVERT_PALETTE_GENERATE,
1 << bpp, TRUE, FALSE, "dummy");
cmap = gimp_image_get_colormap (tmp_image, num_colors);
cmap = gimp_image_get_colormap (tmp_image, NULL, num_colors);
if (*num_colors == (1 << bpp) &&
! ico_cmap_contains_black (cmap, *num_colors))
@ -780,7 +780,7 @@ ico_image_get_reduced_buf (GimpDrawable *layer,
if (gimp_drawable_is_indexed (layer))
{
g_free (cmap);
cmap = gimp_image_get_colormap (image, num_colors);
cmap = gimp_image_get_colormap (image, NULL, num_colors);
gimp_image_set_colormap (tmp_image, cmap, *num_colors);
}
else if (gimp_drawable_is_gray (layer))
@ -807,7 +807,7 @@ ico_image_get_reduced_buf (GimpDrawable *layer,
GIMP_CONVERT_PALETTE_GENERATE,
(1<<bpp) - 1, TRUE, FALSE, "dummy");
g_free (cmap);
cmap = gimp_image_get_colormap (tmp_image, num_colors);
cmap = gimp_image_get_colormap (tmp_image, NULL, num_colors);
}
gimp_image_convert_rgb (tmp_image);

2
plug-ins/file-psd/psd-image-res-load.c
View File

@ -1270,7 +1270,7 @@ load_resource_1046 (const PSDimageres *res_a,
/* FIXME - check that we have indexed image */
if (index_count && index_count < 256)
{
cmap = gimp_image_get_colormap (image, &cmap_count);
cmap = gimp_image_get_colormap (image, NULL, &cmap_count);
if (cmap && index_count < cmap_count)
gimp_image_set_colormap (image, cmap, index_count);
g_free (cmap);

2
plug-ins/file-psd/psd-save.c
View File

@ -633,7 +633,7 @@ save_color_mode_data (GOutputStream *output,
case GIMP_INDEXED:
IFDBG(1) g_debug ("\tImage type: INDEXED");
cmap = gimp_image_get_colormap (image, &nColors);
cmap = gimp_image_get_colormap (image, NULL, &nColors);
IFDBG(1) g_debug ("\t\tLength of colormap returned by gimp_image_get_colormap: %d", nColors);
if (nColors == 0)

2
plug-ins/file-tiff/file-tiff-save.c
View File

@ -563,7 +563,7 @@ save_layer (TIFF *tif,
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
cmap = gimp_image_get_colormap (image, &num_colors);
cmap = gimp_image_get_colormap (image, NULL, &num_colors);
if (num_colors == 2 || num_colors == 1)
{

2
plug-ins/file-tiff/file-tiff.c
View File

@ -501,7 +501,7 @@ image_is_monochrome (GimpImage *image)
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
colors = gimp_image_get_colormap (image, &num_colors);
colors = gimp_image_get_colormap (image, NULL, &num_colors);
if (colors)
{

7
plug-ins/print/print-preview.c
View File

@ -816,7 +816,7 @@ print_preview_get_thumbnail (GimpDrawable *drawable,
{
cairo_surface_t *surface;
cairo_format_t format;
guchar *data;
GBytes *data;
guchar *dest;
const guchar *src;
gint src_stride;
@ -828,6 +828,7 @@ print_preview_get_thumbnail (GimpDrawable *drawable,
g_return_val_if_fail (height > 0 && height <= 1024, NULL);
data = gimp_drawable_get_thumbnail_data (drawable,
width, height,
&width, &height, &bpp);
switch (bpp)
@ -849,7 +850,7 @@ print_preview_get_thumbnail (GimpDrawable *drawable,
surface = cairo_image_surface_create (format, width, height);
src = data;
src = g_bytes_get_data (data, NULL);
src_stride = width * bpp;
dest = cairo_image_surface_get_data (surface);
@ -904,7 +905,7 @@ print_preview_get_thumbnail (GimpDrawable *drawable,
dest += dest_stride;
}
g_free (data);
g_bytes_unref (data);
cairo_surface_mark_dirty (surface);

18
plug-ins/script-fu/libscriptfu/scheme-wrapper.c
View File

@ -971,7 +971,7 @@ script_fu_marshal_procedure_call (scheme *sc,
debug_vector (sc, vector, "%ld");
}
}
else if (GIMP_VALUE_HOLDS_UINT8_ARRAY (&value))
else if (G_VALUE_HOLDS (&value, G_TYPE_BYTES))
{
vector = sc->vptr->pair_car (a);
if (! sc->vptr->is_vector (vector))
@ -980,10 +980,7 @@ script_fu_marshal_procedure_call (scheme *sc,
{
guint8 *array;
n_elements = GIMP_VALUES_GET_INT (args, i - 1);
if (n_elements > sc->vptr->vector_length (vector))
return script_length_error_in_vector (sc, i, proc_name, n_elements, vector);
n_elements = sc->vptr->vector_length (vector);
array = g_new0 (guint8, n_elements);
@ -1000,7 +997,7 @@ script_fu_marshal_procedure_call (scheme *sc,
array[j] = (guint8) sc->vptr->ivalue (v_element);
}
gimp_value_take_uint8_array (&value, array, n_elements);
g_value_take_boxed (&value, g_bytes_new_take (array, n_elements));
debug_vector (sc, vector, "%ld");
}
@ -1466,11 +1463,12 @@ script_fu_marshal_procedure_call (scheme *sc,
return_val = sc->vptr->cons (sc, vector, return_val);
}
else if (GIMP_VALUE_HOLDS_UINT8_ARRAY (value))
else if (G_VALUE_HOLDS (value, G_TYPE_BYTES))
{
gint32 n = GIMP_VALUES_GET_INT (values, i);
const guint8 *v = gimp_value_get_uint8_array (value);
pointer vector = sc->vptr->mk_vector (sc, n);
GBytes *v_bytes = g_value_get_boxed (value);
const guint8 *v = g_bytes_get_data (v_bytes, NULL);
gsize n = g_bytes_get_size (v_bytes);
pointer vector = sc->vptr->mk_vector (sc, n);
for (j = 0; j < n; j++)
{

2
plug-ins/script-fu/scripts/script-fu-set-cmap.scm
View File

@ -3,7 +3,7 @@
;
; Change the colormap of an image to the colors in a specified palette.
; Included is script-fu-make-cmap-array (available for use in scripts) which
; returns an INT8ARRAY containing the colors from a specified palette.
; returns a GBytes containing the colors from a specified palette.
; This array can be used as the cmap argument for gimp-image-set-colormap.
; GIMP - The GNU Image Manipulation Program