}
void
-_evas_filter_context_program_reuse(Evas_Filter_Context *ctx)
+_evas_filter_context_program_reuse(void *engine, void *output, Evas_Filter_Context *ctx)
{
Evas_Filter_Buffer *fb;
Eina_List *li;
surface = evas_ector_buffer_render_image_get(fb->buffer);
if (!surface) continue;
- dc = ENFN->context_new(ENC);
- ENFN->context_color_set(ENC, dc, 0, 0, 0, 0);
- ENFN->context_render_op_set(ENC, dc, EVAS_RENDER_COPY);
- ENFN->rectangle_draw(ENC, ENDT, dc, surface, 0, 0, fb->w, fb->h, ctx->async);
- ENFN->context_free(ENC, dc);
+ dc = ENFN->context_new(engine);
+ ENFN->context_color_set(engine, dc, 0, 0, 0, 0);
+ ENFN->context_render_op_set(engine, dc, EVAS_RENDER_COPY);
+ ENFN->rectangle_draw(engine, output, dc, surface, 0, 0, fb->w, fb->h, ctx->async);
+ ENFN->context_free(engine, dc);
fb->dirty = EINA_FALSE;
evas_ector_buffer_engine_image_release(fb->buffer, surface);
}
static Eina_Bool
-_filter_target_render(Evas_Filter_Context *ctx)
+_filter_target_render(void *engine, void *output, Evas_Filter_Context *ctx)
{
Evas_Filter_Buffer *src;
void *drawctx, *image = NULL, *surface;
EINA_SAFETY_ON_NULL_RETURN_VAL(ctx->target.surface, EINA_FALSE);
- drawctx = ENFN->context_new(ENC);
+ drawctx = ENFN->context_new(engine);
surface = ctx->target.surface;
src = _filter_buffer_get(ctx, EVAS_FILTER_BUFFER_OUTPUT_ID);
if (ctx->target.clip_use)
{
- ENFN->context_clip_set(ENC, drawctx, ctx->target.cx, ctx->target.cy,
+ ENFN->context_clip_set(engine, drawctx, ctx->target.cx, ctx->target.cy,
ctx->target.cw, ctx->target.ch);
}
if (ctx->target.color_use)
{
- ENFN->context_multiplier_set(ENC, drawctx,
+ ENFN->context_multiplier_set(engine, drawctx,
ctx->target.r, ctx->target.g,
ctx->target.b, ctx->target.a);
}
if (ctx->target.mask)
{
- ENFN->context_clip_image_set(ENC, drawctx, ctx->target.mask,
+ ENFN->context_clip_image_set(engine, drawctx, ctx->target.mask,
ctx->target.mask_x, ctx->target.mask_y,
ctx->evas, EINA_FALSE);
}
- ENFN->context_render_op_set(ENC, drawctx, ctx->target.rop);
+ ENFN->context_render_op_set(engine, drawctx, ctx->target.rop);
if (ctx->target.map)
{
- ENFN->image_map_draw(ENC, ENDT, drawctx, surface, image,
+ ENFN->image_map_draw(engine, output, drawctx, surface, image,
ctx->target.map, EINA_TRUE, 0, EINA_FALSE);
}
else
{
- ENFN->image_draw(ENC, ENDT, drawctx, surface, image,
+ ENFN->image_draw(engine, output, drawctx, surface, image,
0, 0, src->w, src->h,
ctx->target.x, ctx->target.y, src->w, src->h,
EINA_TRUE, EINA_FALSE);
}
- ENFN->context_free(ENC, drawctx);
+ ENFN->context_free(engine, drawctx);
evas_ector_buffer_engine_image_release(src->buffer, image);
- ENFN->image_free(ENC, surface);
+ ENFN->image_free(engine, surface);
ctx->target.surface = NULL;
return EINA_TRUE;
fail:
- ENFN->image_free(ENC, surface);
+ ENFN->image_free(engine, surface);
ctx->target.surface = NULL;
ERR("Failed to render filter to target canvas!");
}
static Eina_Bool
-_filter_chain_run(Evas_Filter_Context *ctx)
+_filter_chain_run(void *engine, void *output, Evas_Filter_Context *ctx)
{
Evas_Filter_Command *cmd;
Eina_Bool ok = EINA_FALSE;
}
}
- ok = _filter_target_render(ctx);
+ ok = _filter_target_render(engine, output, ctx);
end:
ctx->running = EINA_FALSE;
return ok;
}
+typedef struct _Filter_Thread_Data Filter_Thread_Data;
+struct _Filter_Thread_Data
+{
+ void *engine;
+ void *output;
+ Evas_Filter_Context *ctx;
+};
+
static void
_filter_thread_run_cb(void *data)
{
- _filter_chain_run(data);
+ Filter_Thread_Data *ftd = data;
+
+ _filter_chain_run(ftd->engine, ftd->output, ftd->ctx);
+ free(ftd);
}
static void
}
Eina_Bool
-evas_filter_context_run(Evas_Filter_Context *ctx)
+evas_filter_context_run(void *engine, void *output, Evas_Filter_Context *ctx)
{
_filter_obscured_region_calc(ctx);
ctx->running = EINA_TRUE;
if (ctx->async)
{
- evas_thread_queue_flush(_filter_thread_run_cb, ctx);
+ Filter_Thread_Data *ftd;
+
+ ftd = calloc(1, sizeof (Filter_Thread_Data));
+ if (!ftd) return EINA_FALSE;
+
+ ftd->engine = engine;
+ ftd->output = output;
+ ftd->ctx = ctx;
+
+ evas_thread_queue_flush(_filter_thread_run_cb, ftd);
return EINA_TRUE;
}
- return _filter_chain_run(ctx);
+ return _filter_chain_run(engine, output, ctx);
}
#endif
Eina_Bool
-evas_filter_context_program_use(Evas_Filter_Context *ctx,
+evas_filter_context_program_use(void *engine, void *output,
+ Evas_Filter_Context *ctx,
Evas_Filter_Program *pgm,
Eina_Bool reuse, int object_x, int object_y)
{
XDBG("Using program '%s' for context %p", pgm->name, ctx);
- if (reuse) _evas_filter_context_program_reuse(ctx);
+ if (reuse) _evas_filter_context_program_reuse(engine, output, ctx);
// Copy current state (size, edje state val, color class, etc...)
ctx->w = pgm->state.w;
// Compute and save padding info
evas_filter_program_padding_get(pgm, &ctx->pad.final, &ctx->pad.calculated);
- dc = ENFN->context_new(ENC);
- ENFN->context_color_set(ENC, dc, 255, 255, 255, 255);
+ dc = ENFN->context_new(engine);
+ ENFN->context_color_set(engine, dc, 255, 255, 255, 255);
// Apply all commands
EINA_INLIST_FOREACH(pgm->instructions, instr)
end:
if (!success) evas_filter_context_clear(ctx, EINA_FALSE);
- if (dc) ENFN->context_free(ENC, dc);
+ if (dc) ENFN->context_free(engine, dc);
return success;
}
Eina_Bool evas_filter_context_async_get(Evas_Filter_Context *ctx);
void evas_filter_context_size_get(Evas_Filter_Context *ctx, int *w, int *H);
void evas_filter_context_destroy(Evas_Filter_Context *ctx);
-Eina_Bool evas_filter_context_program_use(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, Eina_Bool reuse, int object_x, int object_y);
+Eina_Bool evas_filter_context_program_use(void *engine, void *output, Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, Eina_Bool reuse, int object_x, int object_y);
void evas_filter_context_proxy_render_all(Evas_Filter_Context *ctx, Eo *eo_obj, Eina_Bool do_async);
void evas_filter_context_post_run_callback_set(Evas_Filter_Context *ctx, Evas_Filter_Cb cb, void *data);
#define evas_filter_context_autodestroy(ctx) evas_filter_context_post_run_callback_set(ctx, ((Evas_Filter_Cb) evas_filter_context_destroy), ctx)
void *evas_filter_buffer_backing_get(Evas_Filter_Context *ctx, int bufid, Eina_Bool render);
Eina_Bool evas_filter_buffer_backing_set(Evas_Filter_Context *ctx, int bufid, void *engine_buffer);
-Eina_Bool evas_filter_context_run(Evas_Filter_Context *ctx);
+Eina_Bool evas_filter_context_run(void *engine, void *output, Evas_Filter_Context *ctx);
Eina_Bool evas_filter_font_draw(Evas_Filter_Context *ctx, void *engine, void *output, void *draw_context, int bufid, Evas_Font_Set *font, int x, int y, Evas_Text_Props *text_props, Eina_Bool do_async);
Eina_Bool evas_filter_target_set(Evas_Filter_Context *ctx, void *draw_context, void *surface, int x, int y, const RGBA_Map *map);