static void
transfer_registration_color (GeglBuffer *src,
GeglBuffer **dst,
gint count)
{
GimpRGB color, test;
GeglBufferIterator *gi;
const Babl *src_format, *dst_format;
gint i, src_bpp, dst_bpp;
gdouble white;
gimp_context_get_foreground (&color);
white = 1.0;
src_format = gegl_buffer_get_format (src);
src_bpp = babl_format_get_bytes_per_pixel (src_format);
dst_format = gegl_buffer_get_format (dst[0]);
dst_bpp = babl_format_get_bytes_per_pixel (dst_format);
gi = gegl_buffer_iterator_new (src, NULL, 0, NULL,
GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
for (i = 0; i < count; i++)
{
gegl_buffer_iterator_add (gi, dst[i], NULL, 0, NULL,
GEGL_BUFFER_READWRITE, GEGL_ABYSS_NONE);
}
while (gegl_buffer_iterator_next (gi))
{
guint j, k;
gpointer src_data, dst_data[MAX_EXTRACT_IMAGES];
src_data = gi->data[0];
for (j = 0; j < count; j++)
dst_data[j] = gi->data[j+1];
for (k = 0; k < gi->length; k++)
{
gulong pos;
pos = k * src_bpp;
gimp_rgba_set_pixel (&test, src_format, ((guchar *)src_data) + pos);
if (gimp_rgb_distance (&test, &color) < 1e-6)
{
for (j = 0; j < count; j++)
{
gpointer data;
data = dst_data[j];
babl_process (babl_fish (babl_format ("Y double"), dst_format),
&white, (guchar *)data + (k * dst_bpp), 1);
}
}
}
}
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *input;
GeglBuffer *output;
if (! o->input_format || ! o->output_format)
{
g_warning ("cast-format: input-format or output-format are not set");
return FALSE;
}
if (babl_format_get_bytes_per_pixel (o->input_format) !=
babl_format_get_bytes_per_pixel (o->output_format))
{
g_warning ("cast-format: input-format and output-format have different bpp");
return FALSE;
}
if (strcmp (output_prop, "output"))
{
g_warning ("cast-format: requested processing of %s pad", output_prop);
return FALSE;
}
input = gegl_operation_context_get_source (context, "input");
if (! input)
{
g_warning ("cast: received NULL input");
return FALSE;
}
output = gegl_buffer_new (roi, o->input_format);
gegl_buffer_copy (input, roi, GEGL_ABYSS_NONE,
output, roi);
gegl_buffer_set_format (output, o->output_format);
g_object_unref (input);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
return TRUE;
}
/* fixme: make the api of this, as well as blank be the
* same as the downscale functions */
static inline void set_half_nearest (GeglTile *dst_tile,
GeglTile *src_tile,
gint width,
gint height,
const Babl *format,
gint i,
gint j)
{
guchar *dst_data = gegl_tile_get_data (dst_tile);
guchar *src_data = gegl_tile_get_data (src_tile);
gint bpp = babl_format_get_bytes_per_pixel (format);
gint x, y;
for (y = 0; y < height / 2; y++)
{
guchar *dst = dst_data +
(
(
(y + j * (height / 2)) * width
) + i * (width / 2)
) * bpp;
guchar *src = src_data + (y * 2 * width) * bpp;
for (x = 0; x < width / 2; x++)
{
memcpy (dst, src, bpp);
dst += bpp;
src += bpp * 2;
}
}
}
TileManager *
gimp_projection_get_tiles_at_level (GimpProjection *proj,
gint level,
gboolean *is_premult)
{
g_return_val_if_fail (GIMP_IS_PROJECTION (proj), NULL);
if (! proj->pyramid)
{
const Babl *format;
gint bytes;
gint width;
gint height;
format = gimp_projection_get_format (GIMP_PICKABLE (proj));
bytes = babl_format_get_bytes_per_pixel (format);
gimp_projectable_get_size (proj->projectable, &width, &height);
proj->pyramid = tile_pyramid_new (bytes, width, height);
tile_pyramid_set_validate_proc (proj->pyramid,
(TileValidateProc) gimp_projection_validate_tile,
proj);
}
return tile_pyramid_get_tiles (proj->pyramid, level, is_premult);
}
void gegl_resample_boxfilter (guchar *dest_buf,
const guchar *source_buf,
const GeglRectangle *dst_rect,
const GeglRectangle *src_rect,
gint s_rowstride,
gdouble scale,
const Babl *format,
gint d_rowstride)
{
const Babl *comp_type = babl_format_get_type (format, 0);
const gint bpp = babl_format_get_bytes_per_pixel (format);
if (comp_type == gegl_babl_float())
gegl_resample_boxfilter_float (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
else if (comp_type == gegl_babl_u8())
gegl_resample_boxfilter_u8 (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
else if (comp_type == gegl_babl_u16())
gegl_resample_boxfilter_u16 (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
else if (comp_type == gegl_babl_u32())
gegl_resample_boxfilter_u32 (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
else if (comp_type == gegl_babl_double())
gegl_resample_boxfilter_double (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
else
gegl_resample_nearest (dest_buf, source_buf, dst_rect, src_rect,
s_rowstride, scale, bpp, d_rowstride);
}
static BablPalette *
make_pal (const Babl *pal_space,
const Babl *format,
const void *data,
int count)
{
BablPalette *pal = NULL;
int bpp = babl_format_get_bytes_per_pixel (format);
babl_assert (count > 0);
pal = babl_malloc (sizeof (BablPalette));
pal->count = count;
pal->format = format;
pal->data = babl_malloc (bpp * count);
pal->data_double = babl_malloc (4 * sizeof(double) * count);
pal->data_u8 = babl_malloc (4 * sizeof(char) * count);
pal->radii = babl_malloc (sizeof (BablPaletteRadius) *
(pal->count - 1) *
pal->count);
memcpy (pal->data, data, bpp * count);
babl_process (babl_fish (format, babl_format_with_space ("RGBA double", pal_space)),
data, pal->data_double, count);
babl_process (babl_fish (format, babl_format_with_space ("R'G'B'A u8", pal_space)),
data, pal->data_u8, count);
babl_palette_init_radii (pal);
babl_palette_reset_hash (pal);
return pal;
}
static cmsUInt32Number
determine_lcms_format (const Babl *babl, cmsHPROFILE profile)
{
cmsUInt32Number format = COLORSPACE_SH (PT_ANY);
gint channels, bpc, alpha;
const Babl *type;
channels = cmsChannelsOf (cmsGetColorSpace (profile));
alpha = babl_format_get_n_components (babl) - channels;
bpc = babl_format_get_bytes_per_pixel (babl)
/ babl_format_get_n_components (babl);
type = babl_format_get_type (babl, 0);
if (type == babl_type ("half") ||
type == babl_type ("float") ||
type == babl_type ("double"))
format |= FLOAT_SH (1);
/* bpc == 8 overflows the bitfield otherwise */
bpc &= 0x07;
/*
* This is needed so the alpha component lines up with RGBA float
* for our memcpy hack later on.
*/
if (alpha > 1 || (alpha && channels != 3))
return 0;
format |= EXTRA_SH (alpha) | CHANNELS_SH (channels) | BYTES_SH (bpc);
return format;
}
static GimpValueArray *
gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
GError **error)
{
GimpPattern *pattern = GIMP_PATTERN (object);
GimpArray *array;
GimpValueArray *return_vals;
array = gimp_array_new (gimp_temp_buf_get_data (pattern->mask),
gimp_temp_buf_get_data_size (pattern->mask),
TRUE);
return_vals =
gimp_pdb_execute_procedure_by_name (dialog->pdb,
dialog->caller_context,
NULL, error,
dialog->callback_name,
G_TYPE_STRING, gimp_object_get_name (object),
GIMP_TYPE_INT32, gimp_temp_buf_get_width (pattern->mask),
GIMP_TYPE_INT32, gimp_temp_buf_get_height (pattern->mask),
GIMP_TYPE_INT32, babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (pattern->mask)),
GIMP_TYPE_INT32, array->length,
GIMP_TYPE_INT8_ARRAY, array,
GIMP_TYPE_INT32, closing,
G_TYPE_NONE);
gimp_array_free (array);
return return_vals;
}
static void
gegl_affine_fast_reflect_x (GeglBuffer *dest,
GeglBuffer *src,
const GeglRectangle *dest_rect,
const GeglRectangle *src_rect)
{
const Babl *format = gegl_buffer_get_format (src);
const gint px_size = babl_format_get_bytes_per_pixel (format),
rowstride = src_rect->width * px_size;
gint i;
guchar *buf = (guchar *) g_malloc (src_rect->height * rowstride);
gegl_buffer_get (src, 1.0, src_rect, format, buf, GEGL_AUTO_ROWSTRIDE);
for (i = 0; i < src_rect->height / 2; i++)
{
gint dest_offset = (src_rect->height - i - 1) * rowstride,
src_offset = i * rowstride,
j;
for (j = 0; j < rowstride; j++)
{
const guchar tmp = buf[src_offset];
buf[src_offset] = buf[dest_offset];
buf[dest_offset] = tmp;
dest_offset++;
src_offset++;
}
}
gegl_buffer_set (dest, dest_rect, format, buf, GEGL_AUTO_ROWSTRIDE);
g_free (buf);
}
/**
* gimp_color_frame_set_color:
* @frame: The #GimpColorFrame.
* @sample_average: The set @color is the result of averaging
* @sample_format: The format of the #GimpDrawable or #GimpImage the @color
* was picked from.
* @pixel: The raw pixel in @sample_format.
* @color: The @color to set.
*
* Sets the color sample to display in the #GimpColorFrame. if
* @sample_average is %TRUE, @pixel represents the sample at the
* center of the average area and will not be displayed.
**/
void
gimp_color_frame_set_color (GimpColorFrame *frame,
gboolean sample_average,
const Babl *sample_format,
gpointer pixel,
const GimpRGB *color)
{
g_return_if_fail (GIMP_IS_COLOR_FRAME (frame));
g_return_if_fail (color != NULL);
if (frame->sample_valid &&
frame->sample_average == sample_average &&
frame->sample_format == sample_format &&
gimp_rgba_distance (&frame->color, color) < 0.0001)
{
frame->color = *color;
return;
}
frame->sample_valid = TRUE;
frame->sample_average = sample_average;
frame->sample_format = sample_format;
frame->color = *color;
memcpy (frame->pixel, pixel, babl_format_get_bytes_per_pixel (sample_format));
gimp_color_frame_update (frame);
}
GimpTempBuf *
tile_manager_get_sub_preview (TileManager *tiles,
const Babl *format,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height)
{
g_return_val_if_fail (tiles != NULL, NULL);
g_return_val_if_fail (format != NULL, NULL);
g_return_val_if_fail (babl_format_get_bytes_per_pixel (format) ==
tile_manager_bpp (tiles), NULL);
g_return_val_if_fail (src_x >= 0 &&
src_x < tile_manager_width (tiles), NULL);
g_return_val_if_fail (src_y >= 0 &&
src_y < tile_manager_height (tiles), NULL);
g_return_val_if_fail (src_width > 0 &&
src_x + src_width <= tile_manager_width (tiles), NULL);
g_return_val_if_fail (src_height > 0 &&
src_y + src_height <= tile_manager_height (tiles),
NULL);
g_return_val_if_fail (dest_width > 0 && dest_height > 0, NULL);
return tile_manager_create_preview (tiles, format,
src_x, src_y, src_width, src_height,
dest_width, dest_height);
}
guchar *
gegl_buffer_introspectable_get (GeglBuffer *buffer,
const GeglRectangle *rect,
gdouble scale,
const gchar *format_name,
GeglAbyssPolicy repeat_mode,
guint *data_length)
{
const Babl *format;
guint bpp;
guchar *result;
*data_length = 0;
if (format_name)
format = babl_format (format_name);
else
format = gegl_buffer_get_format (buffer);
if (rect->width <= 0 || rect->height <= 0)
return NULL;
if (scale <= 0.0)
return NULL;
bpp = babl_format_get_bytes_per_pixel (format);
*data_length = bpp * rect->width * rect->height;
result = g_malloc (*data_length);
gegl_buffer_get (buffer, rect, scale, format, result, GEGL_AUTO_ROWSTRIDE, repeat_mode);
return result;
}
gboolean
gimp_gegl_mask_is_empty (GeglBuffer *buffer)
{
GeglBufferIterator *iter;
const Babl *format;
gint bpp;
g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE);
format = gegl_buffer_get_format (buffer);
bpp = babl_format_get_bytes_per_pixel (format);
iter = gegl_buffer_iterator_new (buffer, NULL, 0, format,
GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1);
while (gegl_buffer_iterator_next (iter))
{
if (! gegl_memeq_zero (iter->items[0].data, bpp * iter->length))
{
gegl_buffer_iterator_stop (iter);
return FALSE;
}
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong n_pixels,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *format = gegl_operation_get_format (operation, "input");
memcpy (out_buf, in_buf, n_pixels * babl_format_get_bytes_per_pixel (format));
if (o->cache != (void *) operation->node->cache)
{
if (o->cache)
{
g_object_unref (o->cache);
o->cache = NULL;
}
if (operation->node->cache)
o->cache = g_object_ref (operation->node->cache);
}
return TRUE;
}
static inline void set_half (GeglTile * dst_tile,
GeglTile * src_tile,
gint width,
gint height,
const Babl * format,
gint i,
gint j)
{
guchar *dst_data = gegl_tile_get_data (dst_tile);
guchar *src_data = gegl_tile_get_data (src_tile);
gint components = babl_format_get_n_components (format);
gint bpp = babl_format_get_bytes_per_pixel (format);
if (i) dst_data += bpp * width / 2;
if (j) dst_data += bpp * width * height / 2;
if (babl_format_get_type (format, 0) == babl_type ("float"))
{
downscale_float (components, width, height, width * bpp, src_data, dst_data);
}
else if (babl_format_get_type (format, 0) == babl_type ("u8"))
{
downscale_u8 (components, width, height, width * bpp, src_data, dst_data);
}
else
{
set_half_nearest (dst_tile, src_tile, width, height, format, i, j);
}
}
static GimpValueArray *
patterns_get_pattern_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
gchar *actual_name = NULL;
gint32 width = 0;
gint32 height = 0;
gint32 mask_bpp = 0;
gint32 length = 0;
guint8 *mask_data = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpPattern *pattern;
if (name && strlen (name))
pattern = gimp_pdb_get_pattern (gimp, name, error);
else
pattern = gimp_context_get_pattern (context);
if (pattern)
{
actual_name = g_strdup (gimp_object_get_name (pattern));
width = gimp_temp_buf_get_width (pattern->mask);
height = gimp_temp_buf_get_height (pattern->mask);
mask_bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (pattern->mask));
length = gimp_temp_buf_get_data_size (pattern->mask);
mask_data = g_memdup (gimp_temp_buf_get_data (pattern->mask), length);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_take_string (gimp_value_array_index (return_vals, 1), actual_name);
g_value_set_int (gimp_value_array_index (return_vals, 2), width);
g_value_set_int (gimp_value_array_index (return_vals, 3), height);
g_value_set_int (gimp_value_array_index (return_vals, 4), mask_bpp);
g_value_set_int (gimp_value_array_index (return_vals, 5), length);
gimp_value_take_int8array (gimp_value_array_index (return_vals, 6), mask_data, length);
}
return return_vals;
}
int
gegl_buffer_iterator_add (GeglBufferIterator *iter,
GeglBuffer *buf,
const GeglRectangle *roi,
gint level,
const Babl *format,
GeglAccessMode access_mode,
GeglAbyssPolicy abyss_policy)
{
GeglBufferIteratorPriv *priv = iter->priv;
int index;
SubIterState *sub;
g_return_val_if_fail (priv->num_buffers < GEGL_BUFFER_MAX_ITERATORS, 0);
index = priv->num_buffers++;
sub = &priv->sub_iter[index];
if (!format)
format = gegl_buffer_get_format (buf);
if (!roi)
roi = &buf->extent;
sub->buffer = buf;
sub->full_rect = *roi;
if (level)
{
sub->full_rect.x >>= level;
sub->full_rect.y >>= level;
sub->full_rect.width >>= level;
sub->full_rect.height >>= level;
}
sub->access_mode = access_mode;
sub->abyss_policy = abyss_policy;
sub->current_tile = NULL;
sub->real_data = NULL;
sub->linear_tile = NULL;
sub->format = format;
sub->format_bpp = babl_format_get_bytes_per_pixel (format);
sub->level = level;
if (index > 0)
{
priv->sub_iter[index].full_rect.width = priv->sub_iter[0].full_rect.width;
priv->sub_iter[index].full_rect.height = priv->sub_iter[0].full_rect.height;
}
//if (level != 0)
// g_warning ("iterator level != 0");
return index;
}
gboolean
gimp_pickable_pick_color (GimpPickable *pickable,
gint x,
gint y,
gboolean sample_average,
gdouble average_radius,
gpointer pixel,
GimpRGB *color)
{
const Babl *format;
gdouble sample[4];
g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), FALSE);
format = gimp_pickable_get_format (pickable);
if (! gimp_pickable_get_pixel_at (pickable, x, y, format, sample))
return FALSE;
gimp_pickable_pixel_to_srgb (pickable, format, sample, color);
if (pixel)
memcpy (pixel, sample, babl_format_get_bytes_per_pixel (format));
if (sample_average)
{
gint count = 0;
gdouble color_avg[4] = { 0.0, 0.0, 0.0, 0.0 };
gint radius = (gint) average_radius;
gint i, j;
format = babl_format ("RaGaBaA double");
for (i = x - radius; i <= x + radius; i++)
for (j = y - radius; j <= y + radius; j++)
if (gimp_pickable_get_pixel_at (pickable, i, j, format, sample))
{
count++;
color_avg[RED] += sample[RED];
color_avg[GREEN] += sample[GREEN];
color_avg[BLUE] += sample[BLUE];
color_avg[ALPHA] += sample[ALPHA];
}
sample[RED] = color_avg[RED] / count;
sample[GREEN] = color_avg[GREEN] / count;
sample[BLUE] = color_avg[BLUE] / count;
sample[ALPHA] = color_avg[ALPHA] / count;
gimp_pickable_pixel_to_srgb (pickable, format, sample, color);
}
return TRUE;
}
static gint
save_contiguous(GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
const Babl *format)
{
GeglProperties *o = GEGL_PROPERTIES(operation);
Priv *p = (Priv*) o->user_data;
gint bytes_per_pixel, bytes_per_row;
gint tile_width = result->width;
gint tile_height = result->height;
guchar *buffer;
gint x, y;
g_return_val_if_fail(p->tiff != NULL, -1);
bytes_per_pixel = babl_format_get_bytes_per_pixel(format);
bytes_per_row = bytes_per_pixel * tile_width;
buffer = g_try_new(guchar, bytes_per_row * tile_height);
g_assert(buffer != NULL);
for (y = result->y; y < result->y + tile_height; y += tile_height)
{
for (x = result->x; x < result->x + tile_width; x += tile_width)
{
GeglRectangle tile = { x, y, tile_width, tile_height };
gint row;
gegl_buffer_get(input, &tile, 1.0, format, buffer,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (row = y; row < y + tile_height; row++)
{
guchar *tile_row = buffer + (bytes_per_row * (row - y));
gint written;
written = TIFFWriteScanline(p->tiff, tile_row, row, 0);
if (!written)
{
g_critical("failed a scanline write on row %d", row);
continue;
}
}
}
}
TIFFFlushData(p->tiff);
g_free(buffer);
return 0;
}
static void
constructed (GObject *object)
{
GeglTileBackend *backend = GEGL_TILE_BACKEND (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (backend->priv->tile_width > 0 && backend->priv->tile_height > 0);
g_assert (backend->priv->format);
backend->priv->px_size = babl_format_get_bytes_per_pixel (backend->priv->format);
backend->priv->tile_size = backend->priv->tile_width * backend->priv->tile_height * backend->priv->px_size;
}
void
gimp_drawable_foreground_extract_siox (GimpDrawable *mask,
SioxState *state,
SioxRefinementType refinement,
gint smoothness,
const gdouble sensitivity[3],
gboolean multiblob,
GimpProgress *progress)
{
GeglBuffer *buffer;
gint x1, y1;
gint x2, y2;
g_return_if_fail (GIMP_IS_DRAWABLE (mask));
g_return_if_fail (babl_format_get_bytes_per_pixel (gimp_drawable_get_format (mask)) == 1);
g_return_if_fail (state != NULL);
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
if (progress)
gimp_progress_start (progress, _("Foreground Extraction"), FALSE);
if (GIMP_IS_CHANNEL (mask))
{
gimp_channel_bounds (GIMP_CHANNEL (mask), &x1, &y1, &x2, &y2);
}
else
{
x1 = 0;
y1 = 0;
x2 = gimp_item_get_width (GIMP_ITEM (mask));
y2 = gimp_item_get_height (GIMP_ITEM (mask));
}
buffer = gimp_drawable_get_buffer (mask);
siox_foreground_extract (state, refinement,
gimp_gegl_buffer_get_tiles (buffer),
x1, y1, x2, y2,
smoothness, sensitivity, multiblob,
(SioxProgressFunc) gimp_progress_set_value,
progress);
if (progress)
gimp_progress_end (progress);
gimp_drawable_update (mask, x1, y1, x2, y2);
}
gint64
gimp_gegl_buffer_get_memsize (GeglBuffer *buffer)
{
if (buffer)
{
const Babl *format = gegl_buffer_get_format (buffer);
return (babl_format_get_bytes_per_pixel (format) *
gegl_buffer_get_width (buffer) *
gegl_buffer_get_height (buffer) +
gimp_g_object_get_memsize (G_OBJECT (buffer)));
}
return 0;
}
gint64
gimp_gegl_pyramid_get_memsize (GeglBuffer *buffer)
{
if (buffer)
{
const Babl *format = gegl_buffer_get_format (buffer);
/* The pyramid levels constitute a geometric sum with a ratio of 1/4. */
return ((gint64) babl_format_get_bytes_per_pixel (format) *
(gint64) gegl_buffer_get_width (buffer) *
(gint64) gegl_buffer_get_height (buffer) * 1.33 +
gimp_g_object_get_memsize (G_OBJECT (buffer)));
}
return 0;
}
static inline void set_half (GeglTile * dst_tile,
GeglTile * src_tile,
gint width,
gint height,
const Babl * format,
gint i,
gint j)
{
guchar *dst_data = gegl_tile_get_data (dst_tile);
guchar *src_data = gegl_tile_get_data (src_tile);
gint bpp = babl_format_get_bytes_per_pixel (format);
if (i) dst_data += bpp * width / 2;
if (j) dst_data += bpp * width * height / 2;
gegl_downscale_2x2 (format, width, height, src_data, width * bpp, dst_data, width * bpp);
}
/**
* gimp_projection_estimate_memsize:
* @type: the projectable's base type
* @precision: the projectable's precision
* @width: projection width
* @height: projection height
*
* Calculates a rough estimate of the memory that is required for the
* projection of an image with the given @width and @height.
*
* Return value: a rough estimate of the memory requirements.
**/
gint64
gimp_projection_estimate_memsize (GimpImageBaseType type,
GimpPrecision precision,
gint width,
gint height)
{
const Babl *format;
gint64 bytes;
if (type == GIMP_INDEXED)
type = GIMP_RGB;
format = gimp_babl_format (type, precision, TRUE);
bytes = babl_format_get_bytes_per_pixel (format);
/* The pyramid levels constitute a geometric sum with a ratio of 1/4. */
return bytes * (gint64) width * (gint64) height * 1.33;
}
GimpTempBuf *
tile_manager_get_preview (TileManager *tiles,
const Babl *format,
gint width,
gint height)
{
g_return_val_if_fail (tiles != NULL, NULL);
g_return_val_if_fail (format != NULL, NULL);
g_return_val_if_fail (babl_format_get_bytes_per_pixel (format) ==
tile_manager_bpp (tiles), NULL);
g_return_val_if_fail (width > 0 && height > 0, NULL);
return tile_manager_create_preview (tiles, format,
0, 0,
tile_manager_width (tiles),
tile_manager_height (tiles),
width, height);
}
static GObject *
constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GeglTileBackend *backend;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
backend = GEGL_TILE_BACKEND (object);
g_assert (backend->priv->tile_width > 0 && backend->priv->tile_height > 0);
g_assert (backend->priv->format);
backend->priv->px_size = babl_format_get_bytes_per_pixel (backend->priv->format);
backend->priv->tile_size = backend->priv->tile_width * backend->priv->tile_height * backend->priv->px_size;
return object;
}
static gint
save_array (GOutputStream *stream,
GeglBuffer *input,
const GeglRectangle *result,
const Babl *format)
{
gint bytes_per_pixel, bytes_per_row;
gint x = result->x, y = result->y;
gint width = result->width - result->x;
gint height = result->height - result->y;
gint column_stride = 32;
gchar *buffer;
gint nb_components ,row;
nb_components = babl_format_get_n_components (format);
bytes_per_pixel = babl_format_get_bytes_per_pixel (format);
write_header (stream, width, height, nb_components, bytes_per_pixel);
bytes_per_row = bytes_per_pixel * width;
buffer = g_try_new (gchar, bytes_per_row * column_stride);
g_assert (buffer != NULL);
for (row = 0; row < height; row += column_stride)
{
GeglRectangle tile = { x, 0, width, 0 };
tile.y = y + row;
tile.height = MIN (column_stride, height - row);
gegl_buffer_get (input, &tile, 1.0, format, buffer,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
write_to_stream (stream, buffer, bytes_per_row * tile.height);
}
g_free (buffer);
return 0;
}
static inline void set_blank (GeglTile *dst_tile,
gint width,
gint height,
const Babl *format,
gint i,
gint j)
{
guchar *dst_data = gegl_tile_get_data (dst_tile);
gint bpp = babl_format_get_bytes_per_pixel (format);
gint rowstride = width * bpp;
gint scanline;
gint bytes = width * bpp / 2;
guchar *dst = dst_data + j * height / 2 * rowstride + i * rowstride / 2;
for (scanline = 0; scanline < height / 2; scanline++)
{
memset (dst, 0x0, bytes);
dst += rowstride;
}
}
void
gegl_buffer_introspectable_set (GeglBuffer *buffer,
const GeglRectangle *rect,
const gchar *format_name,
const guchar *src,
gint src_length)
{
const Babl *format;
guint bpp;
format = babl_format (format_name);
if (rect->width <= 0 || rect->height <= 0)
return;
bpp = babl_format_get_bytes_per_pixel (format);
g_return_if_fail (src_length == bpp * rect->width * rect->height);
gegl_buffer_set (buffer, rect, 0, format, src, 0);
}
