jpeg pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=148a886cc78281028a7877e05d0d0290c44ee111
commit 148a886cc78281028a7877e05d0d0290c44ee111 Author: Jean-Philippe Andre <jp.an...@samsung.com> Date: Mon May 18 21:04:29 2015 +0900 Evas filters: Refactor parser code This is to prepare the changeable states (animation, color, scale...) - Remove use of Eina_Value (simplifies code) - Use proper Lua type for buffers (with pretty __tostring) This adds the buffer methods: width, height, type, name, source --- src/lib/evas/filters/evas_filter_parser.c | 639 ++++++++++++++++++------------ 1 file changed, 393 insertions(+), 246 deletions(-) diff --git a/src/lib/evas/filters/evas_filter_parser.c b/src/lib/evas/filters/evas_filter_parser.c index 16f8071..6b661aa 100644 --- a/src/lib/evas/filters/evas_filter_parser.c +++ b/src/lib/evas/filters/evas_filter_parser.c @@ -260,6 +260,8 @@ static struct { "stretch_xy", EVAS_FILTER_FILL_MODE_STRETCH_XY } }; +static const char *_lua_buffer_meta = "Filter.buffer"; + static Evas_Filter_Fill_Mode _fill_mode_get(Evas_Filter_Instruction *instr); typedef enum @@ -291,7 +293,14 @@ typedef struct _Instruction_Param EINA_INLIST; Eina_Stringshare *name; Value_Type type; - Eina_Value *value; + union { + Eina_Bool b; + int i; + double f; + char *s; + unsigned int c; + Buffer *buf; + } value; Eina_Bool set : 1; Eina_Bool allow_seq : 1; Eina_Bool allow_any_string : 1; @@ -327,6 +336,7 @@ struct _Evas_Filter_Program Eina_Bool padding_calc : 1; // Padding has been calculated Eina_Bool padding_set : 1; // Padding has been forced Eina_Bool changed : 1; // State (w,h) changed, needs re-run of Lua + Eina_Bool input_alpha : 1; }; /* Instructions */ @@ -345,36 +355,38 @@ static Eina_Bool _instruction_param_addv(Evas_Filter_Instruction *instr, const char *name, Value_Type format, Eina_Bool sequential, va_list args) { - const Eina_Value_Type *type = NULL; Instruction_Param *param; + char *s; + param = calloc(1, sizeof(Instruction_Param)); + param->name = eina_stringshare_add(name); + param->type = format; switch (format) { case VT_BOOL: + param->value.b = (va_arg(args, unsigned int) != 0); + break; case VT_INT: - type = EINA_VALUE_TYPE_INT; + param->value.i = va_arg(args, int); break; case VT_REAL: - type = EINA_VALUE_TYPE_DOUBLE; + param->value.f = va_arg(args, double); break; case VT_STRING: + s = va_arg(args, char *); + param->value.s = s ? strdup(s) : NULL; + break; case VT_BUFFER: - type = EINA_VALUE_TYPE_STRING; + param->value.buf = va_arg(args, Buffer *); break; case VT_COLOR: - type = EINA_VALUE_TYPE_UINT; + param->value.c = va_arg(args, DATA32); break; case VT_NONE: default: return EINA_FALSE; } - - param = calloc(1, sizeof(Instruction_Param)); - param->name = eina_stringshare_add(name); - param->type = format; - param->value = eina_value_new(type); param->allow_seq = sequential; - eina_value_vset(param->value, args); instr->params = eina_inlist_append(instr->params, EINA_INLIST_GET(param)); return EINA_TRUE; @@ -405,7 +417,8 @@ _instruction_del(Evas_Filter_Instruction *instr) if (!instr) return; EINA_INLIST_FREE(instr->params, param) { - eina_value_free(param->value); + if (param->type == VT_STRING) + free(param->value.s); eina_stringshare_del(param->name); instr->params = eina_inlist_remove(instr->params, EINA_INLIST_GET(param)); free(param); @@ -431,17 +444,12 @@ _instruction_param_geti(Evas_Filter_Instruction *instr, const char *name, Eina_Bool *isset) { Instruction_Param *param; - int i = 0; EINA_INLIST_FOREACH(instr->params, param) if (!strcasecmp(name, param->name)) { - if (eina_value_get(param->value, &i)) - { - if (isset) *isset = param->set; - return i; - } - else return -1; + if (isset) *isset = param->set; + return param->value.i; } if (isset) *isset = EINA_FALSE; @@ -453,17 +461,12 @@ _instruction_param_getd(Evas_Filter_Instruction *instr, const char *name, Eina_Bool *isset) { Instruction_Param *param; - double i = 0; EINA_INLIST_FOREACH(instr->params, param) if (!strcasecmp(name, param->name)) { - if (eina_value_get(param->value, &i)) - { - if (isset) *isset = param->set; - return i; - } - else return 0.0; + if (isset) *isset = param->set; + return param->value.f; } if (isset) *isset = EINA_FALSE; @@ -475,17 +478,12 @@ _instruction_param_getc(Evas_Filter_Instruction *instr, const char *name, Eina_Bool *isset) { Instruction_Param *param; - DATA32 i = 0; EINA_INLIST_FOREACH(instr->params, param) if (!strcasecmp(name, param->name)) { - if (eina_value_get(param->value, &i)) - { - if (isset) *isset = param->set; - return i; - } - else return 0; + if (isset) *isset = param->set; + return param->value.c; } if (isset) *isset = EINA_FALSE; @@ -497,17 +495,29 @@ _instruction_param_gets(Evas_Filter_Instruction *instr, const char *name, Eina_Bool *isset) { Instruction_Param *param; - const char *str = NULL; EINA_INLIST_FOREACH(instr->params, param) if (!strcasecmp(name, param->name)) { - if (eina_value_get(param->value, &str)) - { - if (isset) *isset = param->set; - return str; - } - else return NULL; + if (isset) *isset = param->set; + return param->value.s; + } + + if (isset) *isset = EINA_FALSE; + return NULL; +} + +static Buffer * +_instruction_param_getbuf(Evas_Filter_Instruction *instr, const char *name, + Eina_Bool *isset) +{ + Instruction_Param *param; + + EINA_INLIST_FOREACH(instr->params, param) + if (!strcasecmp(name, param->name)) + { + if (isset) *isset = param->set; + return param->value.buf; } if (isset) *isset = EINA_FALSE; @@ -620,6 +630,101 @@ _buffer_get(Evas_Filter_Program *pgm, const char *name) } static Eina_Bool +_lua_buffer_push(lua_State *L, Buffer *buf) +{ + Buffer **ptr; + + lua_getglobal(L, buf->name); + if (lua_isnil(L, -1)) + { + ptr = lua_newuserdata(L, sizeof(Buffer **)); + *ptr = buf; + luaL_getmetatable(L, _lua_buffer_meta); + lua_setmetatable(L, -2); + lua_setglobal(L, buf->name); + } + else + { + ERR("to do"); + } + + return EINA_TRUE; +} + +static int +_lua_buffer_tostring(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) + lua_pushstring(L, "nil"); + else + lua_pushfstring(L, "Buffer[#%d %dx%d %s%s%s]", buf->cid, buf->w, buf->h, + buf->alpha ? "alpha" : "rgba", + buf->proxy ? " src: " : "", buf->proxy ? buf->proxy : ""); + return 1; +} + +static int +_lua_buffer_width(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) return 0; + lua_pushnumber(L, buf->w); + return 1; +} + +static int +_lua_buffer_height(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) return 0; + lua_pushnumber(L, buf->h); + return 1; +} + +static int +_lua_buffer_type(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) return 0; + lua_pushstring(L, buf->alpha ? "alpha" : "rgba"); + return 1; +} + +static int +_lua_buffer_name(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) return 0; + lua_pushstring(L, buf->name); + return 1; +} + +static int +_lua_buffer_source(lua_State *L) +{ + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, 1); + buf = pbuf ? *pbuf : NULL; + if (!buf) return 0; + if (!buf->proxy) + lua_pushnil(L); + else + lua_pushstring(L, buf->proxy); + return 1; +} + +static Buffer * _buffer_add(Evas_Filter_Program *pgm, const char *name, Eina_Bool alpha, const char *src) { @@ -628,24 +733,27 @@ _buffer_add(Evas_Filter_Program *pgm, const char *name, Eina_Bool alpha, if (_buffer_get(pgm, name)) { ERR("Buffer '%s' already exists", name); - return EINA_FALSE; + return NULL; } if (alpha && src) { ERR("Can not set proxy buffer as alpha!"); - return EINA_FALSE; + return NULL; } buf = calloc(1, sizeof(Buffer)); - if (!buf) return EINA_FALSE; + if (!buf) return NULL; buf->name = eina_stringshare_add(name); buf->proxy = eina_stringshare_add(src); buf->alpha = alpha; + buf->w = pgm->w; + buf->h = pgm->h; pgm->buffers = eina_inlist_append(pgm->buffers, EINA_INLIST_GET(buf)); + _lua_buffer_push(pgm->L, buf); - return EINA_TRUE; + return buf; } static void @@ -716,18 +824,19 @@ _buffer_instruction_parse_run(lua_State *L, cnt = (pgm->buffers ? eina_inlist_count(pgm->buffers) : 0) + 1; snprintf(bufname, sizeof(bufname), "__buffer%02d", cnt); - ok = _buffer_add(pgm, bufname, alpha, src); + ok = (_buffer_add(pgm, bufname, alpha, src) != NULL); if (!ok) return EINA_FALSE; - lua_pushstring(L, bufname); + lua_getglobal(L, bufname); instr->return_count = 1; return ok; } static Eina_Bool -_buffer_instruction_prepare(Evas_Filter_Instruction *instr) +_buffer_instruction_prepare(Evas_Filter_Program *pgm EINA_UNUSED, + Evas_Filter_Instruction *instr) { EINA_SAFETY_ON_NULL_RETURN_VAL(instr, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(instr->name, EINA_FALSE); @@ -735,7 +844,7 @@ _buffer_instruction_prepare(Evas_Filter_Instruction *instr) instr->type = EVAS_FILTER_MODE_BUFFER; instr->parse_run = _buffer_instruction_parse_run; - _instruction_param_seq_add(instr, "type", VT_BUFFER, "rgba"); + _instruction_param_seq_add(instr, "type", VT_STRING, "rgba"); _instruction_param_seq_add(instr, "src", VT_BUFFER, NULL); return EINA_TRUE; @@ -827,7 +936,7 @@ _blend_padding_update(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr, */ static Eina_Bool -_blend_instruction_prepare(Evas_Filter_Instruction *instr) +_blend_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); @@ -835,8 +944,8 @@ _blend_instruction_prepare(Evas_Filter_Instruction *instr) instr->type = EVAS_FILTER_MODE_BLEND; instr->pad.update = _blend_padding_update; - _instruction_param_seq_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_seq_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_seq_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_seq_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_seq_add(instr, "ox", VT_INT, 0); _instruction_param_seq_add(instr, "oy", VT_INT, 0); _instruction_param_name_add(instr, "color", VT_COLOR, 0xFFFFFFFF); @@ -947,7 +1056,7 @@ _blur_padding_update(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr, */ static Eina_Bool -_blur_instruction_prepare(Evas_Filter_Instruction *instr) +_blur_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); @@ -961,8 +1070,8 @@ _blur_instruction_prepare(Evas_Filter_Instruction *instr) _instruction_param_seq_add(instr, "ox", VT_INT, 0); _instruction_param_seq_add(instr, "oy", VT_INT, 0); _instruction_param_name_add(instr, "color", VT_COLOR, 0xFFFFFFFF); - _instruction_param_name_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_name_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_name_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_name_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_name_add(instr, "count", VT_INT, 0); return EINA_TRUE; @@ -1009,7 +1118,7 @@ _blur_instruction_prepare(Evas_Filter_Instruction *instr) */ static Eina_Bool -_bump_instruction_prepare(Evas_Filter_Instruction *instr) +_bump_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); @@ -1023,8 +1132,8 @@ _bump_instruction_prepare(Evas_Filter_Instruction *instr) _instruction_param_seq_add(instr, "specular", VT_REAL, 0.0); _instruction_param_name_add(instr, "color", VT_COLOR, 0xFFFFFFFF); _instruction_param_name_add(instr, "compensate", VT_BOOL, EINA_FALSE); - _instruction_param_name_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_name_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_name_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_name_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_name_add(instr, "black", VT_COLOR, 0xFF000000); _instruction_param_name_add(instr, "white", VT_COLOR, 0xFFFFFFFF); _instruction_param_name_add(instr, "fillmode", VT_STRING, "repeat"); @@ -1078,7 +1187,7 @@ _bump_instruction_prepare(Evas_Filter_Instruction *instr) */ static Eina_Bool -_curve_instruction_prepare(Evas_Filter_Instruction *instr) +_curve_instruction_prepare(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr) { Instruction_Param *param; @@ -1096,8 +1205,8 @@ _curve_instruction_prepare(Evas_Filter_Instruction *instr) _instruction_param_seq_add(instr, "interpolation", VT_STRING, "linear"); _instruction_param_seq_add(instr, "channel", VT_STRING, "rgb"); - _instruction_param_name_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_name_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_name_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_name_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); return EINA_TRUE; } @@ -1187,7 +1296,7 @@ _displace_padding_update(Evas_Filter_Program *pgm, */ static Eina_Bool -_displace_instruction_prepare(Evas_Filter_Instruction *instr) +_displace_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); @@ -1198,8 +1307,8 @@ _displace_instruction_prepare(Evas_Filter_Instruction *instr) _instruction_param_seq_add(instr, "map", VT_BUFFER, NULL); _instruction_param_seq_add(instr, "intensity", VT_INT, 10); _instruction_param_seq_add(instr, "flags", VT_STRING, "default"); - _instruction_param_name_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_name_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_name_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_name_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_name_add(instr, "fillmode", VT_STRING, "repeat"); return EINA_TRUE; @@ -1234,14 +1343,14 @@ _displace_instruction_prepare(Evas_Filter_Instruction *instr) */ static Eina_Bool -_fill_instruction_prepare(Evas_Filter_Instruction *instr) +_fill_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, "fill"), EINA_FALSE); instr->type = EVAS_FILTER_MODE_FILL; - _instruction_param_seq_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_seq_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_seq_add(instr, "color", VT_COLOR, 0x0); _instruction_param_seq_add(instr, "l", VT_INT, 0); _instruction_param_seq_add(instr, "r", VT_INT, 0); @@ -1318,7 +1427,7 @@ _grow_padding_update(Evas_Filter_Program *pgm, Evas_Filter_Instruction *instr, */ static Eina_Bool -_grow_instruction_prepare(Evas_Filter_Instruction *instr) +_grow_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); @@ -1328,8 +1437,8 @@ _grow_instruction_prepare(Evas_Filter_Instruction *instr) instr->pad.update = _grow_padding_update; _instruction_param_seq_add(instr, "radius", VT_INT, 0); _instruction_param_name_add(instr, "smooth", VT_BOOL, EINA_TRUE); - _instruction_param_name_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_name_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_name_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_name_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); return EINA_TRUE; } @@ -1368,7 +1477,7 @@ _grow_instruction_prepare(Evas_Filter_Instruction *instr) */ static Eina_Bool -_mask_instruction_prepare(Evas_Filter_Instruction *instr) +_mask_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); @@ -1376,8 +1485,8 @@ _mask_instruction_prepare(Evas_Filter_Instruction *instr) instr->type = EVAS_FILTER_MODE_MASK; _instruction_param_seq_add(instr, "mask", VT_BUFFER, NULL); - _instruction_param_seq_add(instr, "src", VT_BUFFER, "input"); - _instruction_param_seq_add(instr, "dst", VT_BUFFER, "output"); + _instruction_param_seq_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); + _instruction_param_seq_add(instr, "dst", VT_BUFFER, _buffer_get(pgm, "output")); _instruction_param_name_add(instr, "color", VT_COLOR, 0xFFFFFFFF); _instruction_param_name_add(instr, "fillmode", VT_STRING, "repeat"); @@ -1453,7 +1562,7 @@ _transform_padding_update(Evas_Filter_Program *pgm, */ static Eina_Bool -_transform_instruction_prepare(Evas_Filter_Instruction *instr) +_transform_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); @@ -1463,7 +1572,7 @@ _transform_instruction_prepare(Evas_Filter_Instruction *instr) instr->pad.update = _transform_padding_update; _instruction_param_seq_add(instr, "dst", VT_BUFFER, NULL); _instruction_param_seq_add(instr, "op", VT_STRING, "vflip"); - _instruction_param_seq_add(instr, "src", VT_BUFFER, "input"); + _instruction_param_seq_add(instr, "src", VT_BUFFER, _buffer_get(pgm, "input")); //_instruction_param_name_add(instr, "ox", VT_INT, 0); _instruction_param_name_add(instr, "oy", VT_INT, 0); @@ -1543,7 +1652,8 @@ _padding_set_padding_update(Evas_Filter_Program *pgm, */ static Eina_Bool -_padding_set_instruction_prepare(Evas_Filter_Instruction *instr) +_padding_set_instruction_prepare(Evas_Filter_Program *pgm EINA_UNUSED, + Evas_Filter_Instruction *instr) { EINA_SAFETY_ON_NULL_RETURN_VAL(instr, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(instr->name, EINA_FALSE); @@ -1605,10 +1715,9 @@ _lua_program_get(lua_State *L) } static Eina_Bool -_lua_parameter_parse(lua_State *L, Instruction_Param *param, int i) +_lua_parameter_parse(Evas_Filter_Program *pgm, lua_State *L, + Instruction_Param *param, int i) { - Eina_Bool ok; - if (!param) return EINA_FALSE; if (param->set) { @@ -1622,27 +1731,33 @@ _lua_parameter_parse(lua_State *L, Instruction_Param *param, int i) case VT_BOOL: if (lua_type(L, i) == LUA_TSTRING) { - ok = EINA_FALSE; + Eina_Bool ok = EINA_FALSE; const char *str = lua_tostring(L, i); Eina_Bool val = _bool_parse(str, &ok); - if (!ok) goto fail; - eina_value_set(param->value, val); + if (!ok) + goto fail; + param->value.b = val; } else if (lua_isboolean(L, i) || lua_isnumber(L, i)) - eina_value_set(param->value, lua_toboolean(L, i)); - else goto fail; + param->value.b = lua_toboolean(L, i); + else + goto fail; break; case VT_INT: - if (!lua_isnumber(L, i)) goto fail; - eina_value_set(param->value, lua_tointeger(L, i)); + if (!lua_isnumber(L, i)) + goto fail; + param->value.i = lua_tointeger(L, i); break; case VT_REAL: - if (!lua_isnumber(L, i)) goto fail; - eina_value_set(param->value, lua_tonumber(L, i)); + if (!lua_isnumber(L, i)) + goto fail; + param->value.f = lua_tonumber(L, i); break; case VT_STRING: - if (lua_type(L, i) != LUA_TSTRING) goto fail; - eina_value_set(param->value, lua_tostring(L, i)); + if (lua_type(L, i) != LUA_TSTRING) + goto fail; + free(param->value.s); + param->value.s = strdup(lua_tostring(L, i)); break; case VT_COLOR: if (lua_isnumber(L, i)) @@ -1654,21 +1769,33 @@ _lua_parameter_parse(lua_State *L, Instruction_Param *param, int i) int B = B_VAL(&color); if (!A && (R || B || G)) A = 0xFF; evas_color_argb_premul(A, &R, &G, &B); - eina_value_set(param->value, ARGB_JOIN(A, R, G, B)); + param->value.c = ARGB_JOIN(A, R, G, B); } else if (lua_type(L, i) == LUA_TSTRING) { - DATA32 color; - ok = _color_parse(lua_tostring(L, i), &color); - if (!ok) goto fail; - eina_value_set(param->value, color); + if (!_color_parse(lua_tostring(L, i), ¶m->value.c)) + goto fail; } - else goto fail; + else + goto fail; break; case VT_BUFFER: - if (lua_type(L, i) != LUA_TSTRING) goto fail; - eina_value_set(param->value, lua_tostring(L, i)); - break; + { + if (lua_type(L, i) == LUA_TSTRING) + { + param->value.buf = _buffer_get(pgm, lua_tostring(L, i)); + if (!param->value.buf) + goto fail; + } + else + { + Buffer **pbuf; + luaL_checkudata(L, i, _lua_buffer_meta); + pbuf = lua_touserdata(L, i); + param->value.buf = pbuf ? *pbuf : NULL; + } + break; + } case VT_NONE: default: // This should not happen @@ -1761,7 +1888,7 @@ _lua_instruction_run(lua_State *L, Evas_Filter_Instruction *instr) goto fail; } - if (!_lua_parameter_parse(L, param, -1)) + if (!_lua_parameter_parse(pgm, L, param, -1)) goto fail; lua_pop(L, 1); } @@ -1771,7 +1898,7 @@ _lua_instruction_run(lua_State *L, Evas_Filter_Instruction *instr) EINA_INLIST_FOREACH(instr->params, param) { if ((++i) > argc) break; - if (!_lua_parameter_parse(L, param, i)) + if (!_lua_parameter_parse(pgm, L, param, i)) goto fail; } } @@ -1795,14 +1922,14 @@ fail: static int _lua_generic_function(lua_State *L, const char *name, - Eina_Bool (* prepare) (Evas_Filter_Instruction *)) + Eina_Bool (* prepare) (Evas_Filter_Program *pgm, Evas_Filter_Instruction *)) { Evas_Filter_Program *pgm = _lua_program_get(L); Evas_Filter_Instruction *instr; Eina_Bool ok; instr = _instruction_new(name); - prepare(instr); + prepare(pgm, instr); ok = _lua_instruction_run(L, instr); if (!ok) @@ -1848,6 +1975,20 @@ _lua_print(lua_State *L) else eina_strbuf_append_printf(s, "%f", d); } + else if (luaL_checkudata(L, i, _lua_buffer_meta)) + { + Buffer *buf, **pbuf; + pbuf = lua_touserdata(L, i); + buf = pbuf ? *pbuf : NULL; + if (!buf) + eina_strbuf_append(s, "Buffer[null]"); + else + eina_strbuf_append_printf(s, "Buffer[#%d %dx%d %s%s%s]", + buf->cid, buf->w, buf->h, + buf->alpha ? "alpha" : "rgba", + buf->proxy ? " src: " : "", + buf->proxy ? buf->proxy : ""); + } else eina_strbuf_append(s, "<>"); eina_strbuf_append_char(s, ' '); @@ -1887,12 +2028,27 @@ LUA_GENERIC_FUNCTION(mask) LUA_GENERIC_FUNCTION(padding_set) LUA_GENERIC_FUNCTION(transform) +static const luaL_Reg buffer_methods[] = { + { "width", _lua_buffer_width }, + { "height", _lua_buffer_height }, + { "type", _lua_buffer_type }, + { "name", _lua_buffer_name }, + { "source", _lua_buffer_source }, + { NULL, NULL } +}; + +static const luaL_Reg buffer_meta[] = { + { "__tostring", _lua_buffer_tostring }, + { NULL, NULL } +}; + static lua_State * _lua_state_create(Evas_Filter_Program *pgm) { lua_State *L; + Buffer *buf; - L = luaL_newstate(); + pgm->L = L = luaL_newstate(); if (!L) { ERR("Could not create a new Lua state"); @@ -1967,16 +2123,20 @@ _lua_state_create(Evas_Filter_Program *pgm) lua_setglobal(L, booleans[k].name); } - // Buffers. Should be input & output only. - { - Buffer *buf; + // Register buffer meta stuff + luaL_openlib(L, _lua_buffer_meta, buffer_methods, 0); + luaL_newmetatable(L, _lua_buffer_meta); + luaL_openlib(L, NULL, buffer_meta, 0); + lua_pushliteral(L, "__index"); + lua_pushvalue(L, -3); + lua_rawset(L, -3); + lua_pushliteral(L, "__metatable"); + lua_pushvalue(L, -3); + lua_rawset(L, -3); + lua_pop(L, 1); - EINA_INLIST_FOREACH(pgm->buffers, buf) - { - lua_pushstring(L, buf->name); - lua_setglobal(L, buf->name); - } - } + _buffer_add(pgm, "input", pgm->input_alpha, NULL); + _buffer_add(pgm, "output", EINA_FALSE, NULL); // Register proxies if (pgm->proxies) @@ -1985,12 +2145,16 @@ _lua_state_create(Evas_Filter_Program *pgm) const char *source; EINA_ITERATOR_FOREACH(it, source) - if (_buffer_get(pgm, source)) - { - lua_pushstring(L, source); - lua_setglobal(L, source); - } - + { + buf = calloc(1, sizeof(Buffer)); + if (!buf) break; + + buf->name = eina_stringshare_add(source); + buf->proxy = eina_stringshare_ref(buf->name); + buf->alpha = EINA_FALSE; + pgm->buffers = eina_inlist_append(pgm->buffers, EINA_INLIST_GET(buf)); + _lua_buffer_push(L, buf); + } eina_iterator_free(it); } @@ -2149,14 +2313,20 @@ evas_filter_program_parse(Evas_Filter_Program *pgm, const char *str) if (ok) ok = !lua_pcall(L, 0, LUA_MULTRET, 0); - if (!ok || !pgm->instructions) + if (!ok) { const char *msg = lua_tostring(L, -1); ERR("Lua parsing failed: %s", msg); lua_close(L); + pgm->L = NULL; + } + else if (!pgm->instructions) + { + ERR("No instructions found in Lua script"); + lua_close(L); + ok = EINA_FALSE; + pgm->L = NULL; } - else - pgm->L = L; pgm->valid = ok; pgm->padding_calc = EINA_FALSE; @@ -2258,8 +2428,7 @@ evas_filter_program_new(const char *name, Eina_Bool input_alpha) pgm = calloc(1, sizeof(Evas_Filter_Program)); if (!pgm) return NULL; pgm->name = eina_stringshare_add(name); - _buffer_add(pgm, "input", input_alpha, NULL); - _buffer_add(pgm, "output", EINA_FALSE, NULL); + pgm->input_alpha = input_alpha; return pgm; } @@ -2304,6 +2473,10 @@ evas_filter_program_source_set_all(Evas_Filter_Program *pgm, ENFN->context_clip_set(ENDT, dc, l, r, t, b); } while (0) #define RESETCLIP() do { ENFN->context_clip_set(ENDT, dc, _l, _r, _t, _b); } while (0) +#define INSTR_PARAM_CHECK(a) do { if (!(a)) { \ + ERR("Argument %s can not be nil in %s!", #a, instr->name); return -1; } \ + } while (0) + static Evas_Filter_Fill_Mode _fill_mode_get(Evas_Filter_Instruction *instr) { @@ -2324,29 +2497,26 @@ _fill_mode_get(Evas_Filter_Instruction *instr) } static int -_instr2cmd_blend(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_blend(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Eina_Bool isset = EINA_FALSE; - const char *src, *dst; DATA32 color; - Buffer *in, *out; + Buffer *src, *dst; Evas_Filter_Fill_Mode fillmode; int cmdid, ox, oy, A, R, G, B; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); ox = _instruction_param_geti(instr, "ox", NULL); oy = _instruction_param_geti(instr, "oy", NULL); color = _instruction_param_getc(instr, "color", &isset); fillmode = _fill_mode_get(instr); - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); if (isset) SETCOLOR(color); - cmdid = evas_filter_command_blend_add(ctx, dc, in->cid, out->cid, ox, oy, + cmdid = evas_filter_command_blend_add(ctx, dc, src->cid, dst->cid, ox, oy, fillmode); if (isset) RESETCOLOR(); if (cmdid < 0) return cmdid; @@ -2355,18 +2525,16 @@ _instr2cmd_blend(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_blur(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_blur(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Eina_Bool colorset = EINA_FALSE, yset = EINA_FALSE, cntset = EINA_FALSE; Evas_Filter_Blur_Type type = EVAS_FILTER_BLUR_DEFAULT; - const char *src, *dst, *typestr; + const char *typestr; DATA32 color; - Buffer *in, *out; + Buffer *src, *dst; int cmdid, ox, oy, rx, ry, A, R, G, B, count; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); ox = _instruction_param_geti(instr, "ox", NULL); oy = _instruction_param_geti(instr, "oy", NULL); rx = _instruction_param_geti(instr, "rx", NULL); @@ -2374,10 +2542,10 @@ _instr2cmd_blur(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, color = _instruction_param_getc(instr, "color", &colorset); typestr = _instruction_param_gets(instr, "type", NULL); count = _instruction_param_geti(instr, "count", &cntset); - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); if (typestr) { @@ -2408,7 +2576,7 @@ _instr2cmd_blur(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, if (!yset) ry = rx; if (colorset) SETCOLOR(color); - cmdid = evas_filter_command_blur_add(ctx, dc, in->cid, out->cid, type, + cmdid = evas_filter_command_blur_add(ctx, dc, src->cid, dst->cid, type, rx, ry, ox, oy, count); if (colorset) RESETCOLOR(); @@ -2416,20 +2584,16 @@ _instr2cmd_blur(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_bump(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_bump(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Bump_Flags flags = EVAS_FILTER_BUMP_NORMAL; Evas_Filter_Fill_Mode fillmode; - const char *src, *dst, *map; DATA32 color, black, white; - Buffer *in, *out, *bump; + Buffer *src, *dst, *map; double azimuth, elevation, depth, specular; int cmdid, compensate; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); - map = _instruction_param_gets(instr, "map", NULL); color = _instruction_param_getc(instr, "color", NULL); white = _instruction_param_getc(instr, "white", NULL); black = _instruction_param_getc(instr, "black", NULL); @@ -2441,14 +2605,14 @@ _instr2cmd_bump(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, fillmode = _fill_mode_get(instr); if (compensate) flags |= EVAS_FILTER_BUMP_COMPENSATE; - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - bump = _buffer_get(pgm, map); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(bump, -1); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + map = _instruction_param_getbuf(instr, "map", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); + INSTR_PARAM_CHECK(map); - cmdid = evas_filter_command_bump_map_add(ctx, dc, in->cid, bump->cid, out->cid, + cmdid = evas_filter_command_bump_map_add(ctx, dc, src->cid, map->cid, dst->cid, azimuth, elevation, depth, specular, black, color, white, flags, fillmode); @@ -2457,23 +2621,26 @@ _instr2cmd_bump(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_displace(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_displace(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Fill_Mode fillmode; Evas_Filter_Displacement_Flags flags = EVAS_FILTER_DISPLACE_STRETCH | EVAS_FILTER_DISPLACE_LINEAR; - const char *src, *dst, *map, *flagsstr; - Buffer *in, *out, *mask; + const char *flagsstr; + Buffer *src, *dst, *map; int cmdid, intensity; Eina_Bool isset = EINA_FALSE; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); - map = _instruction_param_gets(instr, "map", NULL); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + map = _instruction_param_getbuf(instr, "map", NULL); intensity = _instruction_param_geti(instr, "intensity", NULL); flagsstr = _instruction_param_gets(instr, "flags", &isset); fillmode = _fill_mode_get(instr); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); + INSTR_PARAM_CHECK(map); if (!flagsstr) flagsstr = "default"; if (!strcasecmp(flagsstr, "nearest")) @@ -2487,44 +2654,34 @@ _instr2cmd_displace(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, else if (isset) WRN("Invalid flags '%s' in displace operation. Using default instead", flagsstr); - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - mask = _buffer_get(pgm, map); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(mask, -1); - - cmdid = evas_filter_command_displacement_map_add(ctx, dc, in->cid, out->cid, - mask->cid, flags, intensity, + cmdid = evas_filter_command_displacement_map_add(ctx, dc, src->cid, dst->cid, + map->cid, flags, intensity, fillmode); return cmdid; } static int -_instr2cmd_fill(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_fill(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { - const char *bufname; - Buffer *buf; + Buffer *dst; int R, G, B, A, l, r, t, b; Evas_Filter_Command *cmd; Eina_Inlist *il; DATA32 color; int cmdid; - bufname = _instruction_param_gets(instr, "dst", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); color = _instruction_param_getc(instr, "color", NULL); l = _instruction_param_geti(instr, "l", NULL); r = _instruction_param_geti(instr, "r", NULL); t = _instruction_param_geti(instr, "t", NULL); b = _instruction_param_geti(instr, "b", NULL); - - buf = _buffer_get(pgm, bufname); - EINA_SAFETY_ON_NULL_RETURN_VAL(buf, -1); + INSTR_PARAM_CHECK(dst); SETCOLOR(color); - cmdid = evas_filter_command_fill_add(ctx, dc, buf->cid); + cmdid = evas_filter_command_fill_add(ctx, dc, dst->cid); RESETCOLOR(); if (cmdid < 0) return -1; @@ -2542,26 +2699,22 @@ _instr2cmd_fill(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_grow(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_grow(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Command *cmd; - const char *src, *dst; - Buffer *in, *out; + Buffer *src, *dst; Eina_Bool smooth; int cmdid, radius; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); radius = _instruction_param_geti(instr, "radius", NULL); smooth = _instruction_param_geti(instr, "smooth", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - - cmdid = evas_filter_command_grow_add(ctx, dc, in->cid, out->cid, + cmdid = evas_filter_command_grow_add(ctx, dc, src->cid, dst->cid, radius, smooth); cmd = _evas_filter_command_get(ctx, cmdid); @@ -2571,34 +2724,29 @@ _instr2cmd_grow(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_mask(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_mask(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Fill_Mode fillmode; - const char *src, *dst, *msk; - Buffer *in, *out, *mask; + Buffer *src, *dst, *mask; DATA32 color; int R, G, B, A, cmdid; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); - msk = _instruction_param_gets(instr, "mask", NULL); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); + mask = _instruction_param_getbuf(instr, "mask", NULL); color = _instruction_param_getc(instr, "color", NULL); fillmode = _fill_mode_get(instr); - - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - mask = _buffer_get(pgm, msk); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(mask, -1); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); + INSTR_PARAM_CHECK(mask); SETCOLOR(color); - cmdid = evas_filter_command_mask_add(ctx, dc, in->cid, mask->cid, out->cid, fillmode); + cmdid = evas_filter_command_mask_add(ctx, dc, src->cid, mask->cid, dst->cid, fillmode); RESETCOLOR(); if (cmdid < 0) return cmdid; - if (!in->alpha && !mask->alpha && !out->alpha) + if (!src->alpha && !mask->alpha && !dst->alpha) { Evas_Filter_Command *cmd; @@ -2610,23 +2758,25 @@ _instr2cmd_mask(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, } static int -_instr2cmd_curve(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_curve(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Interpolation_Mode mode = EVAS_FILTER_INTERPOLATION_MODE_LINEAR; Evas_Filter_Channel channel = EVAS_FILTER_CHANNEL_RGB; - const char *src, *dst, *points_str, *interpolation, *channel_name; + const char *points_str, *interpolation, *channel_name; DATA8 values[256] = {0}, points[512]; int cmdid, point_count = 0; char *token, *copy = NULL; - Buffer *in, *out; + Buffer *src, *dst; Eina_Bool parse_ok = EINA_FALSE; - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); points_str = _instruction_param_gets(instr, "points", NULL); interpolation = _instruction_param_gets(instr, "interpolation", NULL); channel_name = _instruction_param_gets(instr, "channel", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); if (channel_name) { @@ -2677,30 +2827,27 @@ interpolated: values[x] = x; } - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - - cmdid = evas_filter_command_curve_add(ctx, dc, in->cid, out->cid, values, channel); + cmdid = evas_filter_command_curve_add(ctx, dc, src->cid, dst->cid, values, channel); return cmdid; } static int -_instr2cmd_transform(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_instr2cmd_transform(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { Evas_Filter_Transform_Flags flags; - const char *src, *dst, *op; - Buffer *in, *out; + const char *op; + Buffer *src, *dst; int ox = 0, oy; op = _instruction_param_gets(instr, "op", NULL); - src = _instruction_param_gets(instr, "src", NULL); - dst = _instruction_param_gets(instr, "dst", NULL); + src = _instruction_param_getbuf(instr, "src", NULL); + dst = _instruction_param_getbuf(instr, "dst", NULL); // ox = _instruction_param_geti(instr, "ox", NULL); oy = _instruction_param_geti(instr, "oy", NULL); + INSTR_PARAM_CHECK(src); + INSTR_PARAM_CHECK(dst); if (!strcasecmp(op, "vflip")) flags = EVAS_FILTER_TRANSFORM_VFLIP; @@ -2710,20 +2857,14 @@ _instr2cmd_transform(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, return -1; } - in = _buffer_get(pgm, src); - out = _buffer_get(pgm, dst); - EINA_SAFETY_ON_NULL_RETURN_VAL(in, -1); - EINA_SAFETY_ON_NULL_RETURN_VAL(out, -1); - - return evas_filter_command_transform_add(ctx, dc, in->cid, out->cid, flags, ox, oy); + return evas_filter_command_transform_add(ctx, dc, src->cid, dst->cid, flags, ox, oy); } static int -_command_from_instruction(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, +_command_from_instruction(Evas_Filter_Context *ctx, Evas_Filter_Instruction *instr, void *dc) { - int (* instr2cmd) (Evas_Filter_Context *, Evas_Filter_Program *, - Evas_Filter_Instruction *, void *); + int (* instr2cmd) (Evas_Filter_Context *, Evas_Filter_Instruction *, void *); switch (instr->type) { @@ -2762,7 +2903,7 @@ _command_from_instruction(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, return -1; } - return instr2cmd(ctx, pgm, instr, dc); + return instr2cmd(ctx, instr, dc); } #ifdef FILTERS_DEBUG @@ -2780,31 +2921,37 @@ _instruction_dump(Evas_Filter_Instruction *instr) eina_strbuf_append(str, "({ "); EINA_INLIST_FOREACH(instr->params, param) { - int i; - DATA32 c; - const char *s; - double d; - switch (param->type) { case VT_BOOL: case VT_INT: - eina_value_get(param->value, &i); - eina_strbuf_append_printf(str, "%s%s = %d", comma, param->name, i); + eina_strbuf_append_printf(str, "%s%s = %d", comma, param->name, param->value.i); break; case VT_COLOR: - eina_value_get(param->value, &c); - eina_strbuf_append_printf(str, "%s%s = 0x%08x", comma, param->name, c); + eina_strbuf_append_printf(str, "%s%s = 0x%08x", comma, param->name, param->value.c); break; case VT_REAL: - eina_value_get(param->value, &d); - eina_strbuf_append_printf(str, "%s%s = %f", comma, param->name, d); + eina_strbuf_append_printf(str, "%s%s = %f", comma, param->name, param->value.f); break; case VT_STRING: + if (param->value.s) + eina_strbuf_append_printf(str, "%s%s = \"%s\"", comma, param->name, param->value.s); + else + eina_strbuf_append_printf(str, "%s%s = nil", comma, param->name); + break; case VT_BUFFER: - eina_value_get(param->value, &s); - if (s) eina_strbuf_append_printf(str, "%s%s = \"%s\"", comma, param->name, s); - else eina_strbuf_append_printf(str, "%s%s = nil", comma, param->name); + if (param->value.buf) + { + Buffer *buf = param->value.buf; + eina_strbuf_append_printf(str, "%s%s = Buffer[#%d %dx%d %s%s%s]", + comma, param->name, + buf->cid, buf->w, buf->h, + buf->alpha ? "alpha" : "rgba", + buf->proxy ? " src: " : "", + buf->proxy ? buf->proxy : ""); + } + else + eina_strbuf_append_printf(str, "%s%s = nil", comma, param->name); break; case VT_NONE: default: @@ -2883,7 +3030,7 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx, EINA_INLIST_FOREACH(pgm->instructions, instr) { _instruction_dump(instr); - cmdid = _command_from_instruction(ctx, pgm, instr, dc); + cmdid = _command_from_instruction(ctx, instr, dc); if (cmdid <= 0) goto end; } --