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; }