int main(int argc, char **argv)
{
GeglTile *tile;
GeglBuffer *buf_a, *buf_b, *buf_small_lin, *buf_big_lin;
gpointer shared_data = NULL;
gboolean result = TRUE;
gpointer scratch_data;
GeglRectangle buffer_rect = *GEGL_RECTANGLE(0, 0, 128, 128);
gegl_init (&argc, &argv);
buf_a = gegl_buffer_new (&buffer_rect, babl_format("RGBA u8"));
buf_b = gegl_buffer_new (&buffer_rect, babl_format("RGBA u8"));
buf_small_lin = gegl_buffer_linear_new (&buffer_rect, babl_format("RGBA float"));
buf_big_lin = gegl_buffer_linear_new (GEGL_RECTANGLE(0, 0, 1024, 1024), babl_format("RGBA float"));
tile = gegl_tile_source_get_tile (GEGL_TILE_SOURCE (buf_a), 0, 0, 0);
shared_data = gegl_tile_get_data(tile);
gegl_tile_unref (tile);
if (!assert_is_empty (buf_a, 0, 0, shared_data))
result = FALSE;
if (!assert_is_empty (buf_b, 0, 1, shared_data))
result = FALSE;
if (!assert_is_empty (buf_a, 0, 0, shared_data))
result = FALSE;
if (!assert_is_empty (buf_b, 0, 1, shared_data))
result = FALSE;
if (!assert_is_empty (buf_small_lin, 0, 0, shared_data))
result = FALSE;
if (!assert_is_unshared (buf_big_lin, 0, 0, shared_data))
result = FALSE;
scratch_data = gegl_malloc(4 * buffer_rect.width * buffer_rect.height);
gegl_buffer_get (buf_a, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_b, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_small_lin, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_big_lin, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_free (scratch_data);
g_object_unref(buf_a);
g_object_unref(buf_b);
g_object_unref(buf_small_lin);
g_object_unref(buf_big_lin);
gegl_exit();
if (result)
return SUCCESS;
return FAILURE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
Babl *format = babl_format ("RGBA float");
GeglRectangle rect;
GeglRectangle boundary = get_effective_area (operation);
gint x, y;
gfloat *dst_buf, *src_buf;
rect.x = CLAMP (result->x - op_area->left, boundary.x, boundary.x +
boundary.width);
rect.width = CLAMP (result->width + op_area->left + op_area->right, 0,
boundary.width);
rect.y = CLAMP (result->y - op_area->top, boundary.y, boundary.y +
boundary.width);
rect.height = CLAMP (result->height + op_area->top + op_area->bottom, 0,
boundary.height);
dst_buf = g_new0 (gfloat, result->height * result->width * 4);
src_buf = g_new0 (gfloat, rect.height * rect.width * 4);
gegl_buffer_get (input, 1.0, result, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
gegl_buffer_get (input, 1.0, &rect, format, src_buf, GEGL_AUTO_ROWSTRIDE);
if (o->horizontal)
{
for (y = result->y; y < result->y + result->height; y++)
if ((o->even && (y % 2 == 0)) || (!o->even && (y % 2 != 0)))
deinterlace_horizontal (src_buf, dst_buf, result, &rect, &boundary,
o->even ? 0 : 1,
y, o->size);
}
else
{
for (x = result->x; x < result->x + result->width; x++)
if ((o->even && (x % 2 == 0)) || (!o->even && (x % 2 != 0)))
deinterlace_vertical (src_buf, dst_buf, result, &rect, &boundary,
o->even ? 0 : 1,
x, o->size);
}
gegl_buffer_set (output, result, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *aux,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglBuffer *temp_in;
GeglBuffer *temp_aux;
/* FIXME: just pass the originals buffers if the result rectangle does not
* include both input buffers
*/
temp_in = gegl_buffer_create_sub_buffer (input, result);
temp_aux = gegl_buffer_create_sub_buffer (aux, result);
{
gfloat *buf = g_new0 (gfloat, result->width * result->height * 4);
gfloat *bufB = g_new0 (gfloat, result->width * result->height * 4);
gegl_buffer_get (temp_in, NULL, 1.0, babl_format ("RGBA float"), buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_get (temp_aux, NULL, 1.0, babl_format ("RGBA float"), bufB,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
{
gint offset=0;
gint x,y;
for (y=0;y<gegl_buffer_get_height (output);y++)
for (x=0;x<gegl_buffer_get_width (output);x++)
{
if (x + result->x >= gegl_buffer_get_width (input))
{
buf[offset+0]=bufB[offset+0];
buf[offset+1]=bufB[offset+1];
buf[offset+2]=bufB[offset+2];
buf[offset+3]=bufB[offset+3];
}
offset+=4;
}
}
gegl_buffer_set (output, NULL, 0, babl_format ("RGBA float"), buf,
GEGL_AUTO_ROWSTRIDE);
g_free (buf);
g_free (bufB);
}
g_object_unref (temp_in);
g_object_unref (temp_aux);
return TRUE;
}
TEST ()
{
GeglBuffer *buffer2, *buffer;
GeglRectangle bound = {0, 0, 20, 20};
GeglRectangle dest = {4, 4, 4, 6};
float *blank = g_malloc0 (100000);
gchar *temp = g_malloc0 (100000);
test_start ();
buffer2 = gegl_buffer_new (&bound, babl_format ("Y float"));
buffer = gegl_buffer_new (&bound, babl_format ("Y float"));
vgrad (buffer2);
gegl_buffer_set (buffer2, &dest, 1, babl_format ("Y float"), blank, GEGL_AUTO_ROWSTRIDE);
print_buffer (buffer2);
gegl_buffer_get (buffer2, &bound, 0.5, babl_format ("Y float"), temp, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (buffer, &bound, 0, babl_format ("Y float"), temp, GEGL_AUTO_ROWSTRIDE);
print_buffer (buffer);
vgrad (buffer2);
{
GeglBufferIterator *iterator = gegl_buffer_iterator_new (buffer2,
&dest, 1, babl_format ("Y float"), GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iterator))
{
int i;
gfloat *d = iterator->data[0];
for (i = 0; i < iterator->length; i++)
d[i] = 0;
}
}
print_buffer (buffer2);
gegl_buffer_get (buffer2, &bound, 0.5, babl_format ("Y float"), temp, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (buffer, &bound, 0, babl_format ("Y float"), temp, GEGL_AUTO_ROWSTRIDE);
print_buffer (buffer);
g_object_unref (buffer);
g_object_unref (buffer2);
test_end ();
}
static void
gimp_blend_tool_update_graph (GimpBlendTool *blend_tool)
{
GimpTool *tool = GIMP_TOOL (blend_tool);
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y);
#if 0
if (gimp_blend_tool_is_shapeburst (blend_tool))
{
gfloat start, end;
gegl_buffer_get (blend_tool->dist_buffer,
GEGL_RECTANGLE (blend_tool->start_x - off_x,
blend_tool->start_y - off_y,
1, 1),
1.0, babl_format("Y float"), &start,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_get (blend_tool->dist_buffer,
GEGL_RECTANGLE (blend_tool->end_x - off_x,
blend_tool->end_y - off_y,
1, 1),
1.0, babl_format("Y float"), &end,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
if (start != end)
{
gegl_node_set (blend_tool->subtract_node,
"value", (gdouble) start,
NULL);
gegl_node_set (blend_tool->divide_node,
"value", (gdouble) (end - start),
NULL);
}
}
else
#endif
{
gegl_node_set (blend_tool->render_node,
"start_x", blend_tool->start_x - off_x,
"start_y", blend_tool->start_y - off_y,
"end_x", blend_tool->end_x - off_x,
"end_y", blend_tool->end_y - off_y,
NULL);
}
}
TEST ()
{
GeglBuffer *buffer;
GeglRectangle rect = {0, 0, 50, 50};
GeglRectangle getrect = {0, 0, 12, 8};
guchar *buf;
test_start ();
buffer = gegl_buffer_new (&rect, babl_format ("Y u8"));
checkerboard (buffer, 2, 0.0, 1.0);
buf = g_malloc (getrect.width*getrect.height*sizeof(gfloat));
{
gint i;
for (i=0; i<10; i++)
{
getrect.x=i;
/*getrect.y=i;*/
gegl_buffer_get (buffer, 1.2, &getrect, babl_format ("Y u8"), buf, 0);
print_linear_buffer_u8 (getrect.width, getrect.height, buf);
}
}
gegl_buffer_destroy (buffer);
g_free (buf);
test_end ();
}
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);
}
static void
iir_young_hor_blur (GeglBuffer *src,
const GeglRectangle *rect,
GeglBuffer *dst,
const gdouble *b,
gdouble (*m)[3],
GeglAbyssPolicy policy,
const Babl *format)
{
GeglRectangle cur_row = *rect;
const gint nc = babl_format_get_n_components (format);
gfloat *row = g_new (gfloat, (3 + rect->width + 3) * nc);
gdouble *tmp = g_new (gdouble, (3 + rect->width + 3));
gint v;
cur_row.height = 1;
for (v = 0; v < rect->height; v++)
{
cur_row.y = rect->y + v;
gegl_buffer_get (src, &cur_row, 1.0, format, &row[3 * nc],
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
iir_young_blur_1D (row, tmp, b, m, rect->width, nc, policy);
gegl_buffer_set (dst, &cur_row, 0, format, &row[3 * nc],
GEGL_AUTO_ROWSTRIDE);
}
g_free (tmp);
g_free (row);
}
static GimpTempBuf *
gimp_buffer_get_new_preview (GimpViewable *viewable,
GimpContext *context,
gint width,
gint height)
{
GimpBuffer *buffer = GIMP_BUFFER (viewable);
const Babl *format = gimp_buffer_get_format (buffer);
GimpTempBuf *preview;
if (babl_format_is_palette (format))
format = gimp_babl_format (GIMP_RGB, GIMP_PRECISION_U8_GAMMA,
babl_format_has_alpha (format));
else
format = gimp_babl_format (gimp_babl_format_get_base_type (format),
gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,
gimp_babl_format_get_linear (format)),
babl_format_has_alpha (format));
preview = gimp_temp_buf_new (width, height, format);
gegl_buffer_get (buffer->buffer, GEGL_RECTANGLE (0, 0, width, height),
MIN ((gdouble) width / (gdouble) gimp_buffer_get_width (buffer),
(gdouble) height / (gdouble) gimp_buffer_get_height (buffer)),
format,
gimp_temp_buf_get_data (preview),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
return preview;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
SDLState *state = NULL;
if(!o->chant_data)
o->chant_data = g_new0 (SDLState, 1);
state = o->chant_data;
init_sdl ();
if (!handle)
handle = g_timeout_add (500, idle, NULL);
if (!state->screen ||
state->width != result->width ||
state->height != result->height)
{
state->screen = SDL_SetVideoMode (result->width, result->height, 32, SDL_SWSURFACE);
if (!state->screen)
{
fprintf (stderr, "Unable to set SDL mode: %s\n",
SDL_GetError ());
return -1;
}
state->width = result->width ;
state->height = result->height;
}
/*
* There seems to be a valid faster path to the SDL desired display format
* in B'G'R'A, perhaps babl should have been able to figure this out ito?
*
*/
gegl_buffer_get (input,
NULL,
1.0,
babl_format_new (babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
babl_component ("A"),
NULL),
state->screen->pixels, GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
SDL_UpdateRect (state->screen, 0, 0, 0, 0);
SDL_WM_SetCaption (o->window_title, o->icon_title);
state->width = result->width ;
state->height = result->height;
return TRUE;
}
static void find_best_thumb (void)
{
int frame = 0;
float best_score = 0.0;
frame_thumb = 0;
for (frame = 0; frame < frame_end; frame++)
{
FrameInfo info;
float score;
GeglRectangle terrain_row;
if (horizontal)
terrain_row = (GeglRectangle){frame-frame_start, 0, 1, sizeof (FrameInfo)};
else
terrain_row = (GeglRectangle){0, frame-frame_start, sizeof (FrameInfo), 1};
gegl_buffer_get (terrain, &terrain_row, 1.0, babl_format("RGB u8"),
&info, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
score = score_frame (&info, frame);
if (score > best_score)
{
best_score = score;
frame_thumb = frame;
}
}
fprintf (stderr, "best frame: %i\n", frame_thumb);
}
static int
test_buffer_cast (void)
{
gint result = SUCCESS;
GeglBuffer *buffer = gegl_buffer_new (GEGL_RECTANGLE (0,0,1,1),
babl_format ("R'G'B'A u8"));
GeglBuffer *cbuffer = gegl_buffer_new (GEGL_RECTANGLE (0,0,1,1),
babl_format ("Y u8"));
guchar srcpix[4] = {1,2,3,4};
guchar dstpix[4] = {0};
gegl_buffer_set (buffer, NULL, 0, NULL, srcpix, GEGL_AUTO_ROWSTRIDE);
gegl_buffer_set_format (cbuffer,
babl_format_new ("name", "B' u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
NULL));
gegl_buffer_copy (buffer, NULL, cbuffer, NULL);
gegl_buffer_set_format (cbuffer, NULL);
gegl_buffer_get (cbuffer, NULL, 1.0, NULL,
dstpix, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
if (dstpix[0] != 3)
result = FAILURE;
g_object_unref (buffer);
g_object_unref (cbuffer);
return result;
}
static void
ver_blur (GeglBuffer *src,
const GeglRectangle *src_rect,
GeglBuffer *dst,
const GeglRectangle *dst_rect,
gint radius)
{
gint u, v;
gint i;
gint offset;
gint src_offset;
gint prev_rad = (radius * 4 + 4) * src_rect->width;
gint next_rad = (radius * 4) * src_rect->width;
gint row;
gfloat *src_buf;
gfloat *dst_buf;
gfloat rad1 = 1.0 / (gfloat)(radius * 2 + 1);
src_buf = g_new0 (gfloat, src_rect->width * src_rect->height * 4);
dst_buf = g_new0 (gfloat, dst_rect->width * dst_rect->height * 4);
gegl_buffer_get (src, src_rect, 1.0, babl_format ("RaGaBaA float"),
src_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
/* prepare: set first row of pixels */
for (v = -radius; v <= radius; v++)
{
row = (v + radius * 2) * src_rect->width;
for (u = 0; u < dst_rect->width; u++)
{
src_offset = SRC_OFFSET;
for (i = 0; i < 4; i++)
dst_buf[u * 4 + i] += src_buf[src_offset + i] * rad1;
}
}
/* skip first row */
offset = dst_rect->width * 4;
for (v = 1; v < dst_rect->height; v++)
{
row = (v + radius * 2) * src_rect->width;
for (u = 0; u < dst_rect->width; u++)
{
src_offset = SRC_OFFSET;
for (i = 0; i < 4; i++)
{
dst_buf[offset] = dst_buf[offset - 4 * dst_rect->width]
- src_buf[src_offset - prev_rad] * rad1
+ src_buf[src_offset + next_rad] * rad1;
src_offset++;
offset++;
}
}
}
gegl_buffer_set (dst, dst_rect, 0, babl_format ("RaGaBaA float"),
dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
}
void
gegl_sampler_get (GeglSampler *self,
gdouble x,
gdouble y,
GeglMatrix2 *scale,
void *output,
GeglAbyssPolicy repeat_mode)
{
if (G_UNLIKELY(!isfinite (x)))
x = 0.0;
if (G_UNLIKELY(!isfinite (y)))
y = 0.0;
if (self->lvel)
{
double factor = 1.0 / (1 << self->lvel);
GeglRectangle rect={floorf (x * factor), floorf (y * factor),1,1};
gegl_buffer_get (self->buffer, &rect, factor, self->format, output, GEGL_AUTO_ROWSTRIDE, repeat_mode);
return;
}
if (gegl_cl_is_accelerated ())
{
GeglRectangle rect={x,y,1,1};
gegl_buffer_cl_cache_flush (self->buffer, &rect);
}
self->get (self, x, y, scale, output, repeat_mode);
}
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;
}
GimpTempBuf *
gimp_image_get_new_preview (GimpViewable *viewable,
GimpContext *context,
gint width,
gint height)
{
GimpImage *image = GIMP_IMAGE (viewable);
const Babl *format;
gboolean linear;
GimpTempBuf *buf;
gdouble scale_x;
gdouble scale_y;
scale_x = (gdouble) width / (gdouble) gimp_image_get_width (image);
scale_y = (gdouble) height / (gdouble) gimp_image_get_height (image);
format = gimp_projectable_get_format (GIMP_PROJECTABLE (image));
linear = gimp_babl_format_get_linear (format);
format = gimp_babl_format (gimp_babl_format_get_base_type (format),
gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,
linear),
babl_format_has_alpha (format));
buf = gimp_temp_buf_new (width, height, format);
gegl_buffer_get (gimp_pickable_get_buffer (GIMP_PICKABLE (image)),
GEGL_RECTANGLE (0, 0, width, height),
MIN (scale_x, scale_y),
gimp_temp_buf_get_format (buf),
gimp_temp_buf_get_data (buf),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
return buf;
}
static void hgrad (GeglBuffer *buffer)
{
gfloat *buf;
gint x,y;
gint i;
gint width, height, x0, y0;
g_object_get (buffer, "x", &x0,
"y", &y0,
"width", &width,
"height", &height,
NULL);
buf = g_malloc (width*height*sizeof(gfloat));
gegl_buffer_get (buffer, NULL, 1.0, babl_format ("Y float"), buf, 0,
GEGL_ABYSS_NONE);
i=0;
for (y=0;y<height;y++)
{
for (x=0;x<width;x++)
{
buf[i++]= (1.0*x)/width;
}
}
gegl_buffer_set (buffer, NULL, 0, babl_format ("Y float"), buf, GEGL_AUTO_ROWSTRIDE);
g_free (buf);
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi,
gint level)
{
GeglRectangle src_rect;
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area;
gfloat* buf;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
src_rect = *roi;
src_rect.x -= op_area->left;
src_rect.y -= op_area->top;
src_rect.width += op_area->left + op_area->right;
src_rect.height += op_area->top + op_area->bottom;
buf = g_new0 (gfloat, src_rect.width * src_rect.height * 4);
gegl_buffer_get (input, &src_rect, 1.0, babl_format ("RGBA float"), buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
dot(buf, roi, o);
gegl_buffer_set (output, roi, 0, babl_format ("RGBA float"), buf, GEGL_AUTO_ROWSTRIDE);
g_free (buf);
return TRUE;
}
static void
iir_young_ver_blur (GeglBuffer *src,
const GeglRectangle *rect,
GeglBuffer *dst,
const gdouble *b,
gdouble (*m)[3],
GeglAbyssPolicy policy,
const Babl *format)
{
GeglRectangle cur_col = *rect;
const gint nc = babl_format_get_n_components (format);
gfloat *col = g_new (gfloat, (3 + rect->height + 3) * nc);
gdouble *tmp = g_new (gdouble, (3 + rect->height + 3));
gint i;
cur_col.width = 1;
for (i = 0; i < rect->width; i++)
{
cur_col.x = rect->x + i;
gegl_buffer_get (src, &cur_col, 1.0, format, &col[3 * nc],
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
iir_young_blur_1D (col, tmp, b, m, rect->height, nc, policy);
gegl_buffer_set (dst, &cur_col, 0, format, &col[3 * nc],
GEGL_AUTO_ROWSTRIDE);
}
g_free (tmp);
g_free (col);
}
static void
median (GeglBuffer *src,
GeglBuffer *dst,
gint radius,
gdouble rank)
{
RankList list = {0};
gint x,y;
gint offset;
gfloat *src_buf;
gfloat *dst_buf;
src_buf = g_new0 (gfloat, gegl_buffer_get_pixel_count (src) * 4);
dst_buf = g_new0 (gfloat, gegl_buffer_get_pixel_count (dst) * 4);
gegl_buffer_get (src, NULL, 1.0, babl_format ("RGBA float"), src_buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
offset = 0;
for (y=0; y<gegl_buffer_get_height (dst); y++)
for (x=0; x<gegl_buffer_get_width (dst); x++)
{
gint u,v;
gfloat *median_pix;
list_clear (&list);
for (v=y-radius;v<=y+radius;v++)
for (u=x-radius;u<=x+radius;u++)
{
gint ru, rv;
ru = (x-u)*(x-u);
rv = (y-v)*(y-v);
if (u >= 0 && u < gegl_buffer_get_width (dst) &&
v >= 0 && v < gegl_buffer_get_height (dst) &&
(ru+rv) < radius* radius
)
{
gfloat *src_pix = src_buf + (u+(v * gegl_buffer_get_width (src))) * 4;
gfloat luma = (src_pix[0] * 0.212671 +
src_pix[1] * 0.715160 +
src_pix[2] * 0.072169);
list_add (&list, luma, src_pix);
}
}
median_pix = list_percentile (&list, rank);
for (u=0; u<4;u++)
dst_buf[offset*4+u] = median_pix[u];
offset++;
}
gegl_buffer_set (dst, NULL, 0, babl_format ("RGBA float"), dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
}
static void
hor_blur (GeglBuffer *src,
const GeglRectangle *src_rect,
GeglBuffer *dst,
const GeglRectangle *dst_rect,
gint radius)
{
gint u,v;
gint i;
gint offset;
gint src_offset;
gint prev_rad = radius * 4 + 4;
gint next_rad = radius * 4;
gint row;
gfloat *src_buf;
gfloat *dst_buf;
gfloat rad1 = 1.0 / (gfloat)(radius * 2 + 1);
src_buf = g_new0 (gfloat, src_rect->width * src_rect->height * 4);
dst_buf = g_new0 (gfloat, dst_rect->width * dst_rect->height * 4);
gegl_buffer_get (src, src_rect, 1.0, babl_format ("RaGaBaA float"),
src_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
offset = 0;
for (v = 0; v < dst_rect->height; v++)
{
/* here just radius, not radius * 2 as in ver_blur beacuse
* we enlarged dst_buf by y earlier */
row = (v + radius) * src_rect->width;
/* prepare - set first column of pixels */
for (u = -radius; u <= radius; u++)
{
src_offset = SRC_OFFSET;
for (i = 0; i < 4; i++)
dst_buf[offset + i] += src_buf[src_offset + i] * rad1;
}
offset += 4;
/* iterate other pixels by moving a window - very fast */
for (u = 1; u < dst_rect->width; u++)
{
src_offset = SRC_OFFSET;
for (i = 0; i < 4; i++)
{
dst_buf[offset] = dst_buf[offset - 4]
- src_buf[src_offset - prev_rad] * rad1
+ src_buf[src_offset + next_rad] * rad1;
src_offset++;
offset++;
}
}
}
gegl_buffer_set (dst, dst_rect, 0, babl_format ("RaGaBaA float"),
dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
}
/* prepare a dummy image */
static void
fill_rgb_image (GeglProperties *o,
AVFrame *pict, int frame_index, int width, int height)
{
Priv *p = (Priv*)o->user_data;
GeglRectangle rect={0,0,width,height};
gegl_buffer_get (p->input, &rect, 1.0, babl_format ("R'G'B' u8"), pict->data[0], GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglRectangle rect;
gfloat *src_buf;
gfloat *dst_buf;
gchar *type;
gint alpha;
gint x;
gint floats_per_pixel;
/*blur-map or emboss*/
if (o->filter && !strcmp (o->filter, "blur-map"))
{
type = "RGBA float";
floats_per_pixel = 4;
alpha = 1;
}
else
{
type = "Y float";
floats_per_pixel = 1;
alpha = 0;
}
rect.x = result->x - op_area->left;
rect.width = result->width + op_area->left + op_area->right;
rect.y = result->y - op_area->top;
rect.height = result->height + op_area->top + op_area->bottom;
src_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel);
dst_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel);
gegl_buffer_get (input, &rect, 1.0, babl_format (type), src_buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
/*do for every row*/
for (x = 0; x < rect.height; x++)
emboss (src_buf, &rect, dst_buf, &rect, x, type, floats_per_pixel, alpha,
DEG_TO_RAD (o->azimuth), DEG_TO_RAD (o->elevation), o->depth);
gegl_buffer_set (output, &rect, 0, babl_format (type),
dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *format = babl_format ("R'G'B'A float");
gint iteration;
gint stride;
gfloat *src_buf;
gfloat *dst_buf;
GeglRectangle rect;
rect = *roi;
rect.x -= o->iterations;
rect.y -= o->iterations;
rect.width += o->iterations*2;
rect.height += o->iterations*2;
stride = roi->width + o->iterations * 2;
src_buf = g_new (gfloat,
(stride) * (roi->height + o->iterations * 2) * 4);
dst_buf = g_new0 (gfloat,
(stride) * (roi->height + o->iterations * 2) * 4);
gegl_buffer_get (input, &rect, 1.0, format, src_buf, stride * 4 * 4,
GEGL_ABYSS_CLAMP);
for (iteration = 0; iteration < o->iterations; iteration++)
{
mean_curvature_flow (src_buf, stride,
dst_buf,
roi->width + (o->iterations - 1 - iteration) * 2,
roi->height + (o->iterations - 1 - iteration) * 2,
stride);
{ /* swap buffers */
gfloat *tmp = src_buf;
src_buf = dst_buf;
dst_buf = tmp;
}
}
gegl_buffer_set (output, roi, 0, format, src_buf, stride * 4 * 4);
g_free (src_buf);
g_free (dst_buf);
return TRUE;
}
GimpTempBuf *
gimp_drawable_get_sub_preview (GimpDrawable *drawable,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height)
{
GimpItem *item;
GimpImage *image;
GeglBuffer *buffer;
GimpTempBuf *preview;
gdouble scale;
gint scaled_x;
gint scaled_y;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (src_x >= 0, NULL);
g_return_val_if_fail (src_y >= 0, NULL);
g_return_val_if_fail (src_width > 0, NULL);
g_return_val_if_fail (src_height > 0, NULL);
g_return_val_if_fail (dest_width > 0, NULL);
g_return_val_if_fail (dest_height > 0, NULL);
item = GIMP_ITEM (drawable);
g_return_val_if_fail ((src_x + src_width) <= gimp_item_get_width (item), NULL);
g_return_val_if_fail ((src_y + src_height) <= gimp_item_get_height (item), NULL);
image = gimp_item_get_image (item);
if (! image->gimp->config->layer_previews)
return NULL;
buffer = gimp_drawable_get_buffer (drawable);
preview = gimp_temp_buf_new (dest_width, dest_height,
gimp_drawable_get_preview_format (drawable));
scale = MIN ((gdouble) dest_width / (gdouble) src_width,
(gdouble) dest_height / (gdouble) src_height);
scaled_x = RINT ((gdouble) src_x * scale);
scaled_y = RINT ((gdouble) src_y * scale);
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y, dest_width, dest_height),
scale,
gimp_temp_buf_get_format (preview),
gimp_temp_buf_get_data (preview),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
return preview;
}
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 gfloat
buffer_sample (GeglBuffer *buffer,
gint x,
gint y,
gint component)
{
gfloat rgba[4];
GeglRectangle roi = {x,y,1,1};
gegl_buffer_get (buffer, &roi, 1.0, babl_format ("RGBA float"), &rgba[0], GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
return rgba[component];
}
static void
process_random_covariant (GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
guint *channel_bits)
{
GeglRectangle line_rect;
guint16 *line_buf;
guint channel_mask [4];
guint y;
line_rect.x = result->x;
line_rect.y = result->y;
line_rect.width = result->width;
line_rect.height = 1;
line_buf = g_new (guint16, line_rect.width * 4);
generate_channel_masks (channel_bits, channel_mask);
for (y = 0; y < result->height; y++)
{
guint x;
gegl_buffer_get (input, &line_rect, 1.0, babl_format ("RGBA u16"), line_buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (x = 0; x < result->width; x++)
{
guint16 *pixel = &line_buf [x * 4];
guint ch;
gint r = g_random_int_range (-65536, 65536);
for (ch = 0; ch < 4; ch++)
{
gdouble value;
gdouble value_clamped;
gdouble quantized;
value = pixel [ch] + (r / (1 << channel_bits [ch]));
value_clamped = CLAMP (value, 0.0, 65535.0);
quantized = quantize_value ((guint) (value_clamped + 0.5), channel_bits [ch], channel_mask [ch]);
pixel [ch] = (guint16) quantized;
}
}
gegl_buffer_set (output, &line_rect, 0, babl_format ("RGBA u16"), line_buf, GEGL_AUTO_ROWSTRIDE);
line_rect.y++;
}
g_free (line_buf);
}
static void
process_bayer (GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
guint *channel_bits)
{
GeglRectangle line_rect;
guint16 *line_buf;
guint channel_mask [4];
guint y;
line_rect.x = result->x;
line_rect.y = result->y;
line_rect.width = result->width;
line_rect.height = 1;
line_buf = g_new (guint16, line_rect.width * 4);
generate_channel_masks (channel_bits, channel_mask);
for (y = 0; y < result->height; y++)
{
guint x;
gegl_buffer_get (input, 1.0, &line_rect, babl_format ("RGBA u16"), line_buf, GEGL_AUTO_ROWSTRIDE);
for (x = 0; x < result->width; x++)
{
guint16 *pixel = &line_buf [x * 4];
guint ch;
for (ch = 0; ch < 4; ch++)
{
gdouble value;
gdouble value_clamped;
gdouble quantized;
value = pixel [ch] + ((bayer_matrix_8x8 [(y % 8) * 8 + (x % 8)] - 32) * 65536.0 / 65.0) / (1 << (channel_bits [ch] - 1));
value_clamped = CLAMP (value, 0.0, 65535.0);
quantized = quantize_value ((guint) (value_clamped + 0.5), channel_bits [ch], channel_mask [ch]);
pixel [ch] = (guint16) quantized;
}
}
gegl_buffer_set (output, &line_rect, babl_format ("RGBA u16"), line_buf, GEGL_AUTO_ROWSTRIDE);
line_rect.y++;
}
g_free (line_buf);
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
if (o->pixbuf)
{
GdkPixbuf **pixbuf = o->pixbuf;
const Babl *babl;
const Babl *format;
guchar *temp;
GeglRectangle *rect = gegl_operation_source_get_bounding_box (operation, "input");
gchar *name;
gboolean has_alpha;
gint bps;
g_object_get (input, "format", &format, NULL);
has_alpha = babl_format_has_alpha (format);
/* pixbuf from data only support 8bit bps */
bps = 8;
name = g_strdup_printf ("R'G'B'%s u%i",
has_alpha ? "A" : "",
bps);
babl = babl_format (name);
temp = g_malloc (rect->width * rect->height * bps);
gegl_buffer_get (input, rect, 1.0, babl, temp, GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
if (temp) {
*pixbuf = gdk_pixbuf_new_from_data (temp,
GDK_COLORSPACE_RGB,
has_alpha,
bps,
rect->width, rect->height,
rect->width * (has_alpha ? 4 : 3) * bps/8,
(GdkPixbufDestroyNotify) g_free, NULL);
}
else {
g_warning (G_STRLOC ": inexistant data, unable to create GdkPixbuf.");
}
g_free (name);
}
return TRUE;
}
