evas: make filter handle multi output.

6 files changed, 57 insertions, 36 deletions

diff --git a/src/lib/evas/canvas/evas_filter_mixin.c b/src/lib/evas/canvas/evas_filter_mixin.c
index ab9a8191d0..3f3292ec04 100644
--- a/src/lib/evas/canvas/evas_filter_mixin.c
+++ b/src/lib/evas/canvas/evas_filter_mixin.c
@@ -387,7 +387,7 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
 
    if (filter)
      {
-        ok = evas_filter_context_program_use(filter, pd->data->chain, EINA_TRUE, X, Y);
+        ok = evas_filter_context_program_use(engine, output, filter, pd->data->chain, EINA_TRUE, X, Y);
         if (!ok)
           {
              evas_filter_context_destroy(filter);
@@ -401,7 +401,7 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
         filter = evas_filter_context_new(obj->layer->evas, do_async, 0);
 
         // Run script
-        ok = evas_filter_context_program_use(filter, pd->data->chain, EINA_FALSE, X, Y);
+        ok = evas_filter_context_program_use(engine, output, filter, pd->data->chain, EINA_FALSE, X, Y);
         if (!filter || !ok)
           {
              ERR("Parsing failed?");
@@ -449,7 +449,7 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
 
    // Run the filter now (maybe async)
    efl_ref(eo_obj);
-   ok = evas_filter_context_run(filter);
+   ok = evas_filter_context_run(engine, output, filter);
    if (!ok) ERR("Filter program failed to run!");
 
    return ok;
diff --git a/src/lib/evas/canvas/evas_object_textblock.c b/src/lib/evas/canvas/evas_object_textblock.c
index a5325e6c1d..79abde8b94 100644
--- a/src/lib/evas/canvas/evas_object_textblock.c
+++ b/src/lib/evas/canvas/evas_object_textblock.c
@@ -13505,7 +13505,7 @@ evas_object_textblock_render(Evas_Object *eo_obj EINA_UNUSED,
         ctx = evas_filter_context_new(obj->layer->evas, do_async, ti->gfx_filter);
         evas_filter_state_prepare(eo_obj, &state, ti);
         evas_filter_program_state_set(pgm, &state);
-        ok = evas_filter_context_program_use(ctx, pgm, EINA_FALSE, 0, 0);
+        ok = evas_filter_context_program_use(engine, output, ctx, pgm, EINA_FALSE, 0, 0);
         if (!ok)
           {
              evas_filter_context_destroy(ctx);
@@ -13819,7 +13819,7 @@ evas_object_textblock_render(Evas_Object *eo_obj EINA_UNUSED,
                   else if (ctx)
                     {
                        evas_filter_context_post_run_callback_set(ctx, _filter_cb, obj->layer->evas);
-                       evas_filter_context_run(ctx);
+                       evas_filter_context_run(engine, output, ctx);
                     }
                }
           }
diff --git a/src/lib/evas/filters/evas_filter.c b/src/lib/evas/filters/evas_filter.c
index ca03b5dbbe..e95296258b 100644
--- a/src/lib/evas/filters/evas_filter.c
+++ b/src/lib/evas/filters/evas_filter.c
@@ -169,7 +169,7 @@ evas_filter_context_proxy_render_all(Evas_Filter_Context *ctx, Eo *eo_obj,
 }
 
 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;
@@ -189,11 +189,11 @@ _evas_filter_context_program_reuse(Evas_Filter_Context *ctx)
         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);
@@ -1578,14 +1578,14 @@ evas_filter_target_set(Evas_Filter_Context *ctx, void *draw_context,
 }
 
 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);
@@ -1598,48 +1598,48 @@ _filter_target_render(Evas_Filter_Context *ctx)
 
    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!");
@@ -1797,7 +1797,7 @@ _filter_command_run(Evas_Filter_Command *cmd)
 }
 
 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;
@@ -1814,7 +1814,7 @@ _filter_chain_run(Evas_Filter_Context *ctx)
           }
      }
 
-   ok = _filter_target_render(ctx);
+   ok = _filter_target_render(engine, output, ctx);
 
 end:
    ctx->running = EINA_FALSE;
@@ -1826,10 +1826,21 @@ end:
    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
@@ -1882,7 +1893,7 @@ _filter_obscured_region_calc(Evas_Filter_Context *ctx)
 }
 
 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);
 
@@ -1890,11 +1901,20 @@ evas_filter_context_run(Evas_Filter_Context *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);
 }
 
 
diff --git a/src/lib/evas/filters/evas_filter_parser.c b/src/lib/evas/filters/evas_filter_parser.c
index c9fbe1e387..d01299c5bd 100644
--- a/src/lib/evas/filters/evas_filter_parser.c
+++ b/src/lib/evas/filters/evas_filter_parser.c
@@ -3475,7 +3475,8 @@ _instruction_dump(Evas_Filter_Instruction *instr)
 #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)
 {
@@ -3489,7 +3490,7 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
 
    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;
@@ -3521,8 +3522,8 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
    // 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)
@@ -3537,7 +3538,7 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
 
 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;
 }
 
diff --git a/src/lib/evas/filters/evas_filter_private.h b/src/lib/evas/filters/evas_filter_private.h
index f6faea3838..5cc22befe0 100644
--- a/src/lib/evas/filters/evas_filter_private.h
+++ b/src/lib/evas/filters/evas_filter_private.h
@@ -301,7 +301,7 @@ Evas_Filter_Buffer *evas_filter_buffer_scaled_get(Evas_Filter_Context *ctx, Evas
 Eina_Bool           evas_filter_interpolate(DATA8* output /* 256 values */, int *points /* 256 values */, Evas_Filter_Interpolation_Mode mode);
 int evas_filter_smallest_pow2_larger_than(int val);
 
-void _evas_filter_context_program_reuse(Evas_Filter_Context *ctx);
+void _evas_filter_context_program_reuse(void *engine, void *output, Evas_Filter_Context *ctx);
 void evas_filter_parser_shutdown(void);
 
 #define E_READ  ECTOR_BUFFER_ACCESS_FLAG_READ
diff --git a/src/lib/evas/include/evas_filter.h b/src/lib/evas/include/evas_filter.h
index 3f88970dc0..175069c7a7 100644
--- a/src/lib/evas/include/evas_filter.h
+++ b/src/lib/evas/include/evas_filter.h
@@ -151,7 +151,7 @@ void                    *evas_filter_context_data_get(Evas_Filter_Context *ctx);
 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)
@@ -163,7 +163,7 @@ int                      evas_filter_buffer_proxy_new(Evas_Filter_Context *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);