From 081e318d90646c8b9c4e750c08224223120cb3bc Mon Sep 17 00:00:00 2001 From: Shinwoo Kim Date: Fri, 27 Sep 2019 15:30:36 +0900 Subject: [PATCH] evas filter: Implement grayscale filter in pure GL Summary: Initial version implementing grayscale filter in pure GL. This patch needs a logt of love as 5bce712 did. Grasyscale formula: https://www.tutorialspoint.com/dip/grayscale_to_rgb_conversion.htm Test Plan: 1. Create filter_example with following . efl_gfx_filter_program_set(image, "grayscale ()", "grayscale"); 2. Run. ELM_ACCEL=gl ./filter_example Reviewers: Hermet, jsuya Subscribers: ali.alzyod, cedric, #reviewers, #committers Tags: #efl Differential Revision: https://phab.enlightenment.org/D9858 --- src/lib/evas/filters/evas_filter.c | 22 +++++ src/lib/evas/filters/evas_filter_parser.c | 39 ++++++++ src/lib/evas/include/evas_filter.h | 12 +++ .../evas/engines/gl_common/evas_gl_common.h | 4 +- .../evas/engines/gl_common/evas_gl_context.c | 92 +++++++++++++++++++ .../evas/engines/gl_common/evas_gl_shader.c | 7 +- .../gl_common/shader/evas_gl_shaders.x | 3 + .../engines/gl_common/shader/fragment.glsl | 4 + .../evas/engines/gl_generic/evas_engine.c | 1 + .../gl_generic/filters/gl_engine_filter.h | 1 + .../gl_generic/filters/gl_filter_grayscale.c | 53 +++++++++++ .../evas/engines/gl_generic/meson.build | 1 + 12 files changed, 237 insertions(+), 2 deletions(-) create mode 100644 src/modules/evas/engines/gl_generic/filters/gl_filter_grayscale.c diff --git a/src/lib/evas/filters/evas_filter.c b/src/lib/evas/filters/evas_filter.c index 332f6dbb27..36c9c5d2b1 100644 --- a/src/lib/evas/filters/evas_filter.c +++ b/src/lib/evas/filters/evas_filter.c @@ -1597,6 +1597,28 @@ evas_filter_command_transform_add(Evas_Filter_Context *ctx, return cmd; } +Evas_Filter_Command * +evas_filter_command_grayscale_add(Evas_Filter_Context *ctx, + void *draw_context EINA_UNUSED, + int inbuf, int outbuf) +{ + Evas_Filter_Command *cmd; + Evas_Filter_Buffer *in, *out; + + EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL); + + in = _filter_buffer_get(ctx, inbuf); + EINA_SAFETY_ON_NULL_RETURN_VAL(in, NULL); + + out = _filter_buffer_get(ctx, outbuf); + EINA_SAFETY_ON_NULL_RETURN_VAL(out, NULL); + + cmd = _command_new(ctx, EVAS_FILTER_MODE_GRAYSCALE, in, NULL, out); + EINA_SAFETY_ON_NULL_RETURN_VAL(out, NULL); + + return cmd; +} + void evas_filter_context_obscured_region_set(Evas_Filter_Context *ctx, Eina_Rectangle rect) { diff --git a/src/lib/evas/filters/evas_filter_parser.c b/src/lib/evas/filters/evas_filter_parser.c index 72308d2a9e..6d89a3518f 100644 --- a/src/lib/evas/filters/evas_filter_parser.c +++ b/src/lib/evas/filters/evas_filter_parser.c @@ -1789,6 +1789,26 @@ _transform_instruction_prepare(Evas_Filter_Program *pgm, Evas_Filter_Instruction return EINA_TRUE; } +/** + @page evasfiltersref + Remove color information from buffer's contents and leave only grayscale + TODO: write down more information + */ + +static Eina_Bool +_grayscale_instruction_prepare(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(instr, EINA_FALSE); + EINA_SAFETY_ON_NULL_RETURN_VAL(instr->name, EINA_FALSE); + EINA_SAFETY_ON_FALSE_RETURN_VAL(!strcasecmp(instr->name, "grayscale"), EINA_FALSE); + + instr->type = EVAS_FILTER_MODE_GRAYSCALE; + _instruction_param_seq_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_seq_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); + + return EINA_TRUE; +} + static int _padding_set_padding_update(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr, @@ -2249,6 +2269,7 @@ LUA_GENERIC_FUNCTION(grow) LUA_GENERIC_FUNCTION(mask) LUA_GENERIC_FUNCTION(padding_set) LUA_GENERIC_FUNCTION(transform) +LUA_GENERIC_FUNCTION(grayscale) static const luaL_Reg _lua_buffer_metamethods[] = { { "__call", _lua_buffer_new }, @@ -2485,6 +2506,7 @@ _lua_state_create(Evas_Filter_Program *pgm) PUSH_LUA_FUNCTION(mask) PUSH_LUA_FUNCTION(padding_set) PUSH_LUA_FUNCTION(transform) + PUSH_LUA_FUNCTION(grayscale) for (unsigned k = 0; k < (sizeof(fill_modes) / sizeof(fill_modes[0])); k++) { @@ -3403,6 +3425,20 @@ _instr2cmd_transform(Evas_Filter_Context *ctx, return evas_filter_command_transform_add(ctx, dc, src->cid, dst->cid, flags, ox, oy); } +static Evas_Filter_Command * +_instr2cmd_grayscale(Evas_Filter_Context *ctx, + Evas_Filter_Instruction *instr, void *dc) +{ + Buffer *src, *dst; + + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); + + return evas_filter_command_grayscale_add(ctx, dc, src->cid, dst->cid); +} + static Eina_Bool _command_from_instruction(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) @@ -3439,6 +3475,9 @@ _command_from_instruction(Evas_Filter_Context *ctx, case EVAS_FILTER_MODE_TRANSFORM: instr2cmd = _instr2cmd_transform; break; + case EVAS_FILTER_MODE_GRAYSCALE: + instr2cmd = _instr2cmd_grayscale; + break; case EVAS_FILTER_MODE_PADDING_SET: case EVAS_FILTER_MODE_BUFFER: return EINA_TRUE; diff --git a/src/lib/evas/include/evas_filter.h b/src/lib/evas/include/evas_filter.h index ffbe797a6d..8dab0a9a34 100644 --- a/src/lib/evas/include/evas_filter.h +++ b/src/lib/evas/include/evas_filter.h @@ -69,6 +69,7 @@ enum _Evas_Filter_Mode EVAS_FILTER_MODE_BUMP, /**< Apply bump mapping (light effect) */ EVAS_FILTER_MODE_TRANSFORM, /**< Apply a simple geometrical transformation */ EVAS_FILTER_MODE_PADDING_SET, /**< Special padding_set instruction to force a specific padding value */ + EVAS_FILTER_MODE_GRAYSCALE, /**< Leave only grayscale information */ EVAS_FILTER_MODE_LAST }; @@ -306,6 +307,17 @@ Evas_Filter_Command *evas_filter_command_bump_map_add(Evas_Filter_Context *c */ Evas_Filter_Command *evas_filter_command_transform_add(Evas_Filter_Context *ctx, void *draw_context, int inbuf, int outbuf, Evas_Filter_Transform_Flags flags, int ox, int oy); +/** + * @brief Remove color information from the buffer + * @param ctx Current filter chain + * @param draw_context Current Evas draw context (ignored) + * @param inbuf Input buffer (Alpha or RGBA) + * @param outbuf Output buffer (Alpha or RGBA), same size as inbuf + * @return Filter command or NULL in case of error + * @internal + */ +Evas_Filter_Command *evas_filter_command_grayscale_add(Evas_Filter_Context *ctx, void *draw_context, int inbuf, int outbuf); + /* Simple binding between a filter object and its sources */ struct _Evas_Filter_Proxy_Binding { diff --git a/src/modules/evas/engines/gl_common/evas_gl_common.h b/src/modules/evas/engines/gl_common/evas_gl_common.h index 2c74423f26..b2cf74bee5 100644 --- a/src/modules/evas/engines/gl_common/evas_gl_common.h +++ b/src/modules/evas/engines/gl_common/evas_gl_common.h @@ -265,7 +265,8 @@ enum _Shader_Type { SHD_FILTER_DISPLACE, SHD_FILTER_CURVE, SHD_FILTER_BLUR_X, - SHD_FILTER_BLUR_Y + SHD_FILTER_BLUR_Y, + SHD_FILTER_GRAYSCALE }; #define ARRAY_BUFFER_USE 500 @@ -680,6 +681,7 @@ void evas_gl_common_filter_curve_push(Evas_Engine_GL_Context *gc, E void evas_gl_common_filter_blur_push(Evas_Engine_GL_Context *gc, Evas_GL_Texture *tex, double sx, double sy, double sw, double sh, double dx, double dy, double dw, double dh, const double * const values, const double * const offsets, int count, double radius, Eina_Bool horiz, Eina_Bool alphaonly); +void evas_gl_common_filter_grayscale_push(Evas_Engine_GL_Context *gc, Evas_GL_Texture *tex, int x, int y, int w, int h); int evas_gl_common_shader_program_init(Evas_GL_Shared *shared); void evas_gl_common_shader_program_shutdown(Evas_GL_Shared *shared); diff --git a/src/modules/evas/engines/gl_common/evas_gl_context.c b/src/modules/evas/engines/gl_common/evas_gl_context.c index bf7e5c1524..9178d3f6b8 100644 --- a/src/modules/evas/engines/gl_common/evas_gl_context.c +++ b/src/modules/evas/engines/gl_common/evas_gl_context.c @@ -3679,6 +3679,98 @@ evas_gl_common_filter_blur_push(Evas_Engine_GL_Context *gc, PUSH_6_COLORS(pn, r, g, b, a); } +void +evas_gl_common_filter_grayscale_push(Evas_Engine_GL_Context *gc, + Evas_GL_Texture *tex, + int x, int y, int w, int h) +{ + double ox1, oy1, ox2, oy2, ox3, oy3, ox4, oy4, pw, ph; + GLfloat tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4; + GLfloat offsetx, offsety; + int r, g, b, a, nomul = 0, pn; + Evas_GL_Program *prog; + Eina_Bool blend = EINA_TRUE; + Eina_Bool smooth = EINA_TRUE; + Shader_Type type = SHD_FILTER_GRAYSCALE; + + r = R_VAL(&gc->dc->mul.col); + g = G_VAL(&gc->dc->mul.col); + b = B_VAL(&gc->dc->mul.col); + a = A_VAL(&gc->dc->mul.col); + if (gc->dc->render_op == EVAS_RENDER_COPY) + blend = EINA_FALSE; + + prog = evas_gl_common_shader_program_get(gc, type, NULL, 0, r, g, b, a, + w, h, w, h, smooth, tex, EINA_FALSE, + NULL, EINA_FALSE, EINA_FALSE, 0, 0, + EINA_FALSE, NULL, &nomul, NULL); + + _filter_data_flush(gc, prog); + EINA_SAFETY_ON_NULL_RETURN(prog); + + pn = _evas_gl_common_context_push(type, gc, tex, NULL, prog, + x, y, w, h, blend, smooth, + 0, 0, 0, 0, 0, EINA_FALSE); + + gc->pipe[pn].region.type = type; + gc->pipe[pn].shader.prog = prog; + gc->pipe[pn].shader.cur_tex = tex->pt->texture; + gc->pipe[pn].shader.cur_texm = 0; + gc->pipe[pn].shader.tex_target = GL_TEXTURE_2D; + gc->pipe[pn].shader.smooth = smooth; + gc->pipe[pn].shader.mask_smooth = 0; + gc->pipe[pn].shader.blend = blend; + gc->pipe[pn].shader.render_op = gc->dc->render_op; + gc->pipe[pn].shader.clip = 0; + gc->pipe[pn].shader.cx = 0; + gc->pipe[pn].shader.cy = 0; + gc->pipe[pn].shader.cw = 0; + gc->pipe[pn].shader.ch = 0; + gc->pipe[pn].array.line = 0; + gc->pipe[pn].array.use_vertex = 1; + gc->pipe[pn].array.use_color = !nomul; + gc->pipe[pn].array.use_texuv = 1; + gc->pipe[pn].array.use_texuv2 = 0; + gc->pipe[pn].array.use_texuv3 = 0; + gc->pipe[pn].array.use_texsam = 0; + gc->pipe[pn].array.use_mask = 0; + gc->pipe[pn].array.use_masksam = 0; + + pipe_region_expand(gc, pn, x, y, w, h); + PIPE_GROW(gc, pn, 6); + + _filter_data_alloc(gc, pn, 0); + + pw = tex->pt->w; + ph = tex->pt->h; + + ox1 = x; + oy1 = y; + ox2 = x + w; + oy2 = y; + ox3 = x + w; + oy3 = y + h; + ox4 = x; + oy4 = y + h; + + offsetx = tex->x; + offsety = tex->y; + + tx1 = ((double)(offsetx) + ox1) / pw; + ty1 = ((double)(offsety) + oy1) / ph; + tx2 = ((double)(offsetx) + ox2) / pw; + ty2 = ((double)(offsety) + oy2) / ph; + tx3 = ((double)(offsetx) + ox3) / pw; + ty3 = ((double)(offsety) + oy3) / ph; + tx4 = ((double)(offsetx) + ox4) / pw; + ty4 = ((double)(offsety) + oy4) / ph; + + PUSH_6_VERTICES(pn, x, y, w, h); + PUSH_6_QUAD(pn, tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4); + + if (!nomul) + PUSH_6_COLORS(pn, r, g, b, a); +} // ---------------------------------------------------------------------------- EAPI void diff --git a/src/modules/evas/engines/gl_common/evas_gl_shader.c b/src/modules/evas/engines/gl_common/evas_gl_shader.c index a4dd632896..7c338674ec 100644 --- a/src/modules/evas/engines/gl_common/evas_gl_shader.c +++ b/src/modules/evas/engines/gl_common/evas_gl_shader.c @@ -45,8 +45,9 @@ typedef enum { SHADER_FLAG_FILTER_BLUR = (1 << 23), SHADER_FLAG_FILTER_DIR_Y = (1 << 24), SHADER_FLAG_FILTER_ALPHA_ONLY = (1 << 25), + SHADER_FLAG_FILTER_GRAYSCALE = (1 << 26), } Shader_Flag; -#define SHADER_FLAG_COUNT 26 +#define SHADER_FLAG_COUNT 27 static const char *_shader_flags[SHADER_FLAG_COUNT] = { "TEX", @@ -75,6 +76,7 @@ static const char *_shader_flags[SHADER_FLAG_COUNT] = { "FILTER_BLUR", "FILTER_DIR_Y", "ALPHA_ONLY", + "FILTER_GRAYSCALE", }; static Eina_Bool compiler_released = EINA_FALSE; @@ -824,6 +826,9 @@ evas_gl_common_shader_flags_get(Evas_GL_Shared *shared, Shader_Type type, flags |= SHADER_FLAG_FILTER_BLUR; flags |= SHADER_FLAG_FILTER_DIR_Y; break; + case SHD_FILTER_GRAYSCALE: + flags |= SHADER_FLAG_FILTER_GRAYSCALE; + break; default: CRI("Impossible shader type."); return 0; diff --git a/src/modules/evas/engines/gl_common/shader/evas_gl_shaders.x b/src/modules/evas/engines/gl_common/shader/evas_gl_shaders.x index 2b071f2316..73ca4bef11 100644 --- a/src/modules/evas/engines/gl_common/shader/evas_gl_shaders.x +++ b/src/modules/evas/engines/gl_common/shader/evas_gl_shaders.x @@ -214,6 +214,9 @@ static const char fragment_glsl[] = "#ifdef SHD_ALPHA_ONLY\n" " c = vec4(c.a, c.a, c.a, c.a);\n" "#endif\n" + "#ifdef SHD_FILTER_GRAYSCALE\n" + " c.rgb = 0.3 * c.r + 0.59 * c.g + 0.11 * c.b;\n" + "#endif\n" "#ifndef SHD_FILTER_BLUR\n" " gl_FragColor =\n" " c\n" diff --git a/src/modules/evas/engines/gl_common/shader/fragment.glsl b/src/modules/evas/engines/gl_common/shader/fragment.glsl index 89f306062a..39fccf1119 100644 --- a/src/modules/evas/engines/gl_common/shader/fragment.glsl +++ b/src/modules/evas/engines/gl_common/shader/fragment.glsl @@ -230,6 +230,10 @@ vec4 fetch_pixel(float ox, float oy) c = vec4(c.a, c.a, c.a, c.a); #endif +#ifdef SHD_FILTER_GRAYSCALE + c.rgb = 0.3 * c.r + 0.59 * c.g + 0.11 * c.b; +#endif + #ifndef SHD_FILTER_BLUR gl_FragColor = diff --git a/src/modules/evas/engines/gl_generic/evas_engine.c b/src/modules/evas/engines/gl_generic/evas_engine.c index 4b0a6c735b..3428cf5620 100644 --- a/src/modules/evas/engines/gl_generic/evas_engine.c +++ b/src/modules/evas/engines/gl_generic/evas_engine.c @@ -3127,6 +3127,7 @@ _gfx_filter_func_get(Render_Engine_GL_Generic *re, Evas_Filter_Command *cmd) case EVAS_FILTER_MODE_FILL: funcptr = gl_filter_fill_func_get(re, cmd); break; case EVAS_FILTER_MODE_MASK: funcptr = gl_filter_mask_func_get(re, cmd); break; //case EVAS_FILTER_MODE_TRANSFORM: funcptr = gl_filter_transform_func_get(re, cmd); break; + case EVAS_FILTER_MODE_GRAYSCALE: funcptr = gl_filter_grayscale_func_get(re, cmd); break; default: return NULL; } diff --git a/src/modules/evas/engines/gl_generic/filters/gl_engine_filter.h b/src/modules/evas/engines/gl_generic/filters/gl_engine_filter.h index 9cb59d1969..b1045d019e 100644 --- a/src/modules/evas/engines/gl_generic/filters/gl_engine_filter.h +++ b/src/modules/evas/engines/gl_generic/filters/gl_engine_filter.h @@ -17,6 +17,7 @@ GL_Filter_Apply_Func gl_filter_displace_func_get(Render_Engine_GL_Generic *re, E GL_Filter_Apply_Func gl_filter_fill_func_get(Render_Engine_GL_Generic *re, Evas_Filter_Command *cmd); GL_Filter_Apply_Func gl_filter_mask_func_get(Render_Engine_GL_Generic *re, Evas_Filter_Command *cmd); //GL_Filter_Apply_Func gl_filter_transform_func_get(Evas_Filter_Command *cmd); +GL_Filter_Apply_Func gl_filter_grayscale_func_get(Render_Engine_GL_Generic *re, Evas_Filter_Command *cmd); #undef DBG #undef INF diff --git a/src/modules/evas/engines/gl_generic/filters/gl_filter_grayscale.c b/src/modules/evas/engines/gl_generic/filters/gl_filter_grayscale.c new file mode 100644 index 0000000000..3e8ef1e5e0 --- /dev/null +++ b/src/modules/evas/engines/gl_generic/filters/gl_filter_grayscale.c @@ -0,0 +1,53 @@ +#include "gl_engine_filter.h" + +static Eina_Bool +_gl_filter_grayscale(Render_Engine_GL_Generic *re, Evas_Filter_Command *cmd) +{ + Evas_Engine_GL_Context *gc; + Evas_GL_Image *image, *surface; + RGBA_Draw_Context *dc_save; + int w, h; + + w = cmd->input->w; + h = cmd->input->h; + EINA_SAFETY_ON_FALSE_RETURN_VAL(w == cmd->output->w, EINA_FALSE); + EINA_SAFETY_ON_FALSE_RETURN_VAL(h == cmd->output->h, EINA_FALSE); + + image = evas_ector_buffer_drawable_image_get(cmd->input->buffer); + EINA_SAFETY_ON_NULL_RETURN_VAL(image, EINA_FALSE); + + surface = evas_ector_buffer_render_image_get(cmd->output->buffer); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, EINA_FALSE); + + gc = gl_generic_context_find(re, 1); + evas_gl_common_context_target_surface_set(gc, surface); + + dc_save = gc->dc; + gc->dc = evas_common_draw_context_new(); + evas_common_draw_context_set_multiplier(gc->dc, cmd->draw.R, cmd->draw.G, cmd->draw.B, cmd->draw.A); + + if (cmd->input == cmd->output) + gc->dc->render_op = EVAS_RENDER_COPY; + else + gc->dc->render_op = _gfx_to_evas_render_op(cmd->draw.rop); + + evas_gl_common_filter_grayscale_push(gc, image->tex, 0, 0, w, h); + + evas_common_draw_context_free(gc->dc); + gc->dc = dc_save; + + evas_ector_buffer_engine_image_release(cmd->input->buffer, image); + evas_ector_buffer_engine_image_release(cmd->output->buffer, surface); + + return EINA_TRUE; +} + +GL_Filter_Apply_Func +gl_filter_grayscale_func_get(Render_Engine_GL_Generic *re EINA_UNUSED, Evas_Filter_Command *cmd) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(cmd, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(cmd->output, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(cmd->input, NULL); + + return _gl_filter_grayscale; +} diff --git a/src/modules/evas/engines/gl_generic/meson.build b/src/modules/evas/engines/gl_generic/meson.build index d18e032f7a..86e5c8fedd 100644 --- a/src/modules/evas/engines/gl_generic/meson.build +++ b/src/modules/evas/engines/gl_generic/meson.build @@ -12,6 +12,7 @@ engine_src = files([ join_paths('filters','gl_filter_displace.c'), join_paths('filters','gl_filter_fill.c'), join_paths('filters','gl_filter_mask.c'), + join_paths('filters','gl_filter_grayscale.c'), ]) common_engine_src = [ 'evas_gl_private.h',