9 files changed, 286 insertions, 95 deletions

diff --git a/src/bin/elementary/test_evas_snapshot.c b/src/bin/elementary/test_evas_snapshot.c
index 94d6e160be..13e045804c 100644
--- a/src/bin/elementary/test_evas_snapshot.c
+++ b/src/bin/elementary/test_evas_snapshot.c
@@ -111,7 +111,6 @@ test_evas_snapshot(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
                   efl_pack_grid(grid, efl_added, 1, 1, GRID_SIZE - 2, GRID_SIZE - 2),
                   efl_gfx_visible_set(efl_added, 1));
 
-
    // Objects above snapshot
    // 1. Opaque rect, not changing
    o = evas_object_rectangle_add(win);
diff --git a/src/lib/evas/canvas/evas_filter_mixin.c b/src/lib/evas/canvas/evas_filter_mixin.c
index 45db424c0a..fab03baa60 100644
--- a/src/lib/evas/canvas/evas_filter_mixin.c
+++ b/src/lib/evas/canvas/evas_filter_mixin.c
@@ -43,6 +43,8 @@ _filter_end_sync(Evas_Filter_Context *ctx, Evas_Object_Protected_Data *obj,
                  Evas_Filter_Data *pd, Eina_Bool success)
 {
    void *previous = pd->data->output;
+   Eina_Bool destroy = !pd->data->reuse;
+   Evas_Object_Filter_Data *fcow;
    Eo *eo_obj = obj->object;
 
    if (!success)
@@ -50,10 +52,10 @@ _filter_end_sync(Evas_Filter_Context *ctx, Evas_Object_Protected_Data *obj,
         ERR("Filter failed at runtime!");
         evas_filter_invalid_set(eo_obj, EINA_TRUE);
         evas_filter_dirty(eo_obj);
+        destroy = EINA_TRUE;
      }
    else
      {
-        Evas_Object_Filter_Data *fcow;
         void *output = evas_filter_buffer_backing_get(ctx, EVAS_FILTER_BUFFER_OUTPUT_ID, EINA_FALSE);
 
         fcow = FCOW_BEGIN(pd);
@@ -61,9 +63,29 @@ _filter_end_sync(Evas_Filter_Context *ctx, Evas_Object_Protected_Data *obj,
         FCOW_END(fcow, pd);
      }
 
-   // Destroy context as we won't reuse it.
-   evas_filter_buffer_backing_release(ctx, previous);
-   evas_filter_context_destroy(ctx);
+   if (EINA_UNLIKELY(ctx != pd->data->context))
+     {
+        ERR("Filter context has changed! Destroying it now...");
+        fcow = FCOW_BEGIN(pd);
+        evas_filter_context_destroy(fcow->context);
+        fcow->context = NULL;
+        FCOW_END(fcow, pd);
+        destroy = EINA_TRUE;
+     }
+
+   if (destroy)
+     {
+        evas_filter_buffer_backing_release(ctx, previous);
+        evas_filter_context_destroy(ctx);
+        ctx = NULL;
+     }
+
+   if (pd->data->context != ctx)
+     {
+        fcow = FCOW_BEGIN(pd);
+        fcow->context = ctx;
+        FCOW_END(fcow, pd);
+     }
 }
 
 static void
@@ -192,13 +214,6 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
         Evas_Object_Filter_Data *fcow;
         Evas_Filter_Padding pad;
 
-        /* NOTE: Filter rendering is now done ENTIRELY on CPU.
-         * So we rely on cache/cache2 to allocate a real image buffer,
-         * that we can draw to. The OpenGL texture will be created only
-         * after the rendering has been done, as we simply push the output
-         * image to GL.
-         */
-
         W = obj->cur->geometry.w;
         H = obj->cur->geometry.h;
         X = obj->cur->geometry.x;
@@ -217,7 +232,7 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
                                        obj->cur->clipper->cur->cache.clip.b,
                                        obj->cur->clipper->cur->cache.clip.a);
         else
-           ENFN->context_multiplier_unset(output, context);
+          ENFN->context_multiplier_unset(output, context);
 
         if (!pd->data->chain)
           {
@@ -295,22 +310,57 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
              _evas_filter_state_set_internal(pd->data->chain, pd);
           }
 
-        filter = evas_filter_context_new(obj->layer->evas, do_async, 0);
-
-        // Run script
-        ok = evas_filter_context_program_use(filter, pd->data->chain);
-        if (!filter || !ok)
+        filter = pd->data->context;
+        if (filter)
           {
-             ERR("Parsing failed?");
-             evas_filter_context_destroy(filter);
+             int prev_w, prev_h;
+             Eina_Bool was_async;
 
-             if (!pd->data->invalid)
+             was_async = evas_filter_context_async_get(filter);
+             evas_filter_context_size_get(filter, &prev_w, &prev_h);
+             if ((!pd->data->reuse) || (was_async != do_async) ||
+                 (prev_w != W) || (prev_h != H))
                {
                   fcow = FCOW_BEGIN(pd);
-                  fcow->invalid = EINA_TRUE;
+                  fcow->context = NULL;
                   FCOW_END(fcow, pd);
+                  evas_filter_context_destroy(filter);
+                  filter = NULL;
+               }
+          }
+
+        if (filter)
+          {
+             ok = evas_filter_context_program_reuse(filter, pd->data->chain);
+             if (!ok)
+               {
+                  fcow = FCOW_BEGIN(pd);
+                  fcow->context = NULL;
+                  FCOW_END(fcow, pd);
+                  evas_filter_context_destroy(filter);
+                  filter = NULL;
+               }
+          }
+
+        if (!filter)
+          {
+             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);
+             if (!filter || !ok)
+               {
+                  ERR("Parsing failed?");
+                  evas_filter_context_destroy(filter);
+
+                  if (!pd->data->invalid)
+                    {
+                       fcow = FCOW_BEGIN(pd);
+                       fcow->invalid = EINA_TRUE;
+                       FCOW_END(fcow, pd);
+                    }
+                  return EINA_FALSE;
                }
-             return EINA_FALSE;
           }
 
         // Proxies
@@ -336,15 +386,17 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
 
         // Add post-run callback and run filter
         evas_filter_context_post_run_callback_set(filter, _filter_cb, pd);
-        ok = evas_filter_run(filter);
 
         fcow = FCOW_BEGIN(pd);
+        fcow->context = filter;
         fcow->changed = EINA_FALSE;
         fcow->async = do_async;
         fcow->prev_obscured = fcow->obscured;
-        fcow->invalid = !ok;
+        fcow->invalid = EINA_FALSE;
         FCOW_END(fcow, pd);
 
+        ok = evas_filter_context_run(filter);
+
         if (ok)
           {
              DBG("Effect rendering done.");
@@ -352,6 +404,9 @@ evas_filter_object_render(Eo *eo_obj, Evas_Object_Protected_Data *obj,
           }
         else
           {
+             fcow = FCOW_BEGIN(pd);
+             fcow->invalid = EINA_TRUE;
+             FCOW_END(fcow, pd);
              ERR("Rendering failed.");
              return EINA_FALSE;
           }
@@ -377,6 +432,9 @@ _efl_canvas_filter_internal_efl_gfx_filter_filter_program_set(Eo *eo_obj, Evas_F
    {
       fcow->obj = obj;
 
+      if (fcow->context)
+        evas_filter_context_destroy(fcow->context);
+
       // Parse filter program
       evas_filter_program_del(fcow->chain);
       eina_stringshare_replace(&fcow->name, name);
@@ -613,6 +671,9 @@ _efl_canvas_filter_internal_efl_object_destructor(Eo *eo_obj, Evas_Filter_Data *
    obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
    e = obj->layer->evas;
 
+   if (pd->data->context)
+     evas_filter_context_destroy(pd->data->context);
+
    if (pd->data->output)
      {
         if (!pd->data->async)
diff --git a/src/lib/evas/canvas/evas_object_main.c b/src/lib/evas/canvas/evas_object_main.c
index cab4bd1731..b62ffe67c4 100644
--- a/src/lib/evas/canvas/evas_object_main.c
+++ b/src/lib/evas/canvas/evas_object_main.c
@@ -33,7 +33,7 @@ static const Evas_Object_Protected_State default_state = {
   1.0, 0, EVAS_RENDER_BLEND, EINA_FALSE, EINA_FALSE, EINA_FALSE, EINA_FALSE, EINA_FALSE
 };
 static const Evas_Object_Filter_Data default_filter = {
-  NULL, NULL, NULL, NULL, NULL, NULL, {}, {}, NULL, {}, EINA_FALSE, EINA_FALSE, EINA_TRUE
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, {}, {}, NULL, {}, EINA_FALSE, EINA_FALSE, EINA_TRUE, EINA_TRUE
 };
 const void * const evas_object_filter_cow_default = &default_filter;
 static const Evas_Object_Mask_Data default_mask = {
diff --git a/src/lib/evas/canvas/evas_object_textblock.c b/src/lib/evas/canvas/evas_object_textblock.c
index 05166b914a..8032abfc59 100644
--- a/src/lib/evas/canvas/evas_object_textblock.c
+++ b/src/lib/evas/canvas/evas_object_textblock.c
@@ -13476,7 +13476,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);
+        ok = evas_filter_context_program_use(ctx, pgm, EINA_FALSE);
         if (!ok)
           {
              evas_filter_context_destroy(ctx);
@@ -13790,7 +13790,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_run(ctx);
+                       evas_filter_context_run(ctx);
                     }
                }
           }
diff --git a/src/lib/evas/filters/evas_filter.c b/src/lib/evas/filters/evas_filter.c
index 3b4c7ff6a0..c0990a0ef7 100644
--- a/src/lib/evas/filters/evas_filter.c
+++ b/src/lib/evas/filters/evas_filter.c
@@ -30,6 +30,7 @@
 static void _buffer_free(Evas_Filter_Buffer *fb);
 static void _command_del(Evas_Filter_Context *ctx, Evas_Filter_Command *cmd);
 static Evas_Filter_Buffer *_buffer_alloc_new(Evas_Filter_Context *ctx, int w, int h, Eina_Bool alpha_only, Eina_Bool render, Eina_Bool draw);
+static void _filter_buffer_unlock_all(Evas_Filter_Context *ctx);
 
 #define DRAW_COLOR_SET(r, g, b, a) do { cmd->draw.R = r; cmd->draw.G = g; cmd->draw.B = b; cmd->draw.A = a; } while (0)
 #define DRAW_CLIP_SET(_x, _y, _w, _h) do { cmd->draw.clip.x = _x; cmd->draw.clip.y = _y; cmd->draw.clip.w = _w; cmd->draw.clip.h = _h; } while (0)
@@ -72,24 +73,37 @@ evas_filter_context_async_get(Evas_Filter_Context *ctx)
    return ctx->async;
 }
 
+void
+evas_filter_context_size_get(Evas_Filter_Context *ctx, int *w, int *h)
+{
+   if (w) *w = ctx->w;
+   if (h) *h = ctx->h;
+}
+
 /* Private function to reset the filter context. Used from parser.c */
 void
-evas_filter_context_clear(Evas_Filter_Context *ctx)
+evas_filter_context_clear(Evas_Filter_Context *ctx, Eina_Bool keep_buffers)
 {
-   Evas_Filter_Buffer *fb;
    Evas_Filter_Command *cmd;
+   Evas_Filter_Buffer *fb;
 
    if (!ctx) return;
 
-   EINA_LIST_FREE(ctx->buffers, fb)
-     _buffer_free(fb);
-   EINA_INLIST_FREE(ctx->commands, cmd)
-     _command_del(ctx, cmd);
+   if (ctx->target.surface) ENFN->image_free(ENDT, ctx->target.surface);
+   if (ctx->target.mask) ENFN->image_free(ENDT, ctx->target.mask);
+   ctx->target.surface = NULL;
+   ctx->target.mask = NULL;
+
+   if (!keep_buffers)
+     {
+        ctx->last_buffer_id = 0;
+        EINA_LIST_FREE(ctx->buffers, fb)
+          _buffer_free(fb);
+     }
 
-   ctx->buffers = NULL;
-   ctx->commands = NULL;
-   ctx->last_buffer_id = 0;
    ctx->last_command_id = 0;
+   EINA_INLIST_FREE(ctx->commands, cmd)
+     _command_del(ctx, cmd);
 
    // Note: don't reset post_run, as it it set by the client
 }
@@ -109,6 +123,7 @@ evas_filter_context_proxy_render_all(Evas_Filter_Context *ctx, Eo *eo_obj,
 {
    Evas_Object_Protected_Data *source;
    Evas_Object_Protected_Data *obj;
+   void *proxy_surface;
    Evas_Filter_Buffer *fb;
    Eina_List *li;
 
@@ -122,6 +137,7 @@ evas_filter_context_proxy_render_all(Evas_Filter_Context *ctx, Eo *eo_obj,
           source = efl_data_scope_get(fb->source, EFL_CANVAS_OBJECT_CLASS);
           _assert(fb->w == source->cur->geometry.w);
           _assert(fb->h == source->cur->geometry.h);
+          proxy_surface = source->proxy->surface;
           if (source->proxy->surface && !source->proxy->redraw)
             {
                XDBG("Source already rendered: '%s' of type '%s'",
@@ -134,33 +150,75 @@ evas_filter_context_proxy_render_all(Evas_Filter_Context *ctx, Eo *eo_obj,
                    source->proxy->redraw ? "redraw" : "no surface");
                evas_render_proxy_subrender(ctx->evas->evas, fb->source, eo_obj, obj, EINA_FALSE, do_async);
             }
-          _filter_buffer_backing_free(fb);
+          if (fb->buffer)
+            {
+               void *old_surface;
+
+               old_surface = evas_ector_buffer_drawable_image_get(fb->buffer);
+               if (old_surface && (old_surface != proxy_surface))
+                 _filter_buffer_backing_free(fb);
+            }
           XDBG("Source #%d '%s' has dimensions %dx%d", fb->id, fb->source_name, fb->w, fb->h);
-          fb->buffer = ENFN->ector_buffer_wrap(ENDT, obj->layer->evas->evas, source->proxy->surface);
+          if (!fb->buffer) fb->buffer = ENFN->ector_buffer_wrap(ENDT, obj->layer->evas->evas, source->proxy->surface);
           fb->alpha_only = EINA_FALSE;
        }
 }
 
-void
-evas_filter_context_destroy(Evas_Filter_Context *ctx)
+Eina_Bool
+evas_filter_context_program_reuse(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm)
 {
    Evas_Filter_Buffer *fb;
-   Evas_Filter_Command *cmd;
+   Eina_List *li;
 
-   if (!ctx) return;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pgm, EINA_FALSE);
 
-   EINA_LIST_FREE(ctx->buffers, fb)
-     _buffer_free(fb);
-   EINA_INLIST_FREE(ctx->commands, cmd)
-     _command_del(ctx, cmd);
+   _filter_buffer_unlock_all(ctx);
 
-   if (ctx->target.mask)
-     ctx->evas->engine.func->image_free(ctx->evas->engine.data.output, ctx->target.mask);
+   EINA_LIST_FOREACH(ctx->buffers, li, fb)
+     {
+        void *dc, *surface;
+
+        fb->used = EINA_FALSE;
+        fb->locked = EINA_FALSE;
+
+        if (!fb->is_render) continue;
+        if (fb->source) continue;
+
+        surface = evas_ector_buffer_render_image_get(fb->buffer);
+        if (!surface) continue;
+
+        dc = ENFN->context_new(ENDT);
+        ENFN->context_color_set(ENDT, dc, 0, 0, 0, 0);
+        ENFN->context_render_op_set(ENDT, dc, EVAS_RENDER_COPY);
+        ENFN->rectangle_draw(ENDT, dc, surface, 0, 0, fb->w, fb->h, ctx->async);
+        ENFN->context_free(ENDT, dc);
+        fb->dirty = EINA_FALSE;
+     }
+
+   return evas_filter_context_program_use(ctx, pgm, EINA_TRUE);
+}
+
+static void
+_context_destroy(void *data)
+{
+   Evas_Filter_Context *ctx = data;
 
+   evas_filter_context_clear(ctx, EINA_FALSE);
    free(ctx);
 }
 
 void
+evas_filter_context_destroy(Evas_Filter_Context *ctx)
+{
+   // FIXME: This is not locked...
+   if (ctx->running)
+     evas_post_render_job_add(ctx->evas, _context_destroy, ctx);
+   else
+     _context_destroy(ctx);
+}
+
+void
 evas_filter_context_post_run_callback_set(Evas_Filter_Context *ctx,
                                           Evas_Filter_Cb cb, void *data)
 {
@@ -213,6 +271,8 @@ evas_filter_context_buffers_allocate_all(Evas_Filter_Context *ctx)
    Eina_List *li;
    unsigned w, h;
 
+   if (ctx->run_count > 0) return EINA_TRUE;
+
    EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, EINA_FALSE);
    w = ctx->w;
    h = ctx->h;
@@ -231,6 +291,7 @@ evas_filter_context_buffers_allocate_all(Evas_Filter_Context *ctx)
              in->h = h;
           }
 
+        // FIXME: No need for stretch buffers with GL!
         if (fillmode & EVAS_FILTER_FILL_MODE_STRETCH_XY)
           {
              unsigned sw = w, sh = h;
@@ -322,15 +383,69 @@ alloc_fail:
 }
 
 int
-evas_filter_buffer_empty_new(Evas_Filter_Context *ctx, Eina_Bool alpha_only)
+evas_filter_buffer_empty_new(Evas_Filter_Context *ctx, int w, int h, Eina_Bool alpha_only)
 {
    Evas_Filter_Buffer *fb;
+   Eina_List *li;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, -1);
 
-   fb = _buffer_empty_new(ctx, 0, 0, alpha_only, EINA_FALSE);
+   EINA_LIST_FOREACH(ctx->buffers, li, fb)
+     {
+        if ((fb->alpha_only == alpha_only) &&
+            (fb->w == w) && (fb->h == h) && !fb->dirty && !fb->used)
+          {
+             fb->used = EINA_TRUE;
+             return fb->id;
+          }
+     }
+
+   fb = _buffer_empty_new(ctx, w, h, alpha_only, EINA_FALSE);
    if (!fb) return -1;
 
+   fb->used = EINA_TRUE;
+   return fb->id;
+}
+
+int
+evas_filter_buffer_proxy_new(Evas_Filter_Context *ctx, Evas_Filter_Proxy_Binding *pb,
+                             int *w, int *h)
+{
+   Evas_Object_Protected_Data *source;
+   Evas_Filter_Buffer *fb;
+   Eina_List *li;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, -1);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pb, -1);
+
+   source = efl_data_scope_get(pb->eo_source, EFL_CANVAS_OBJECT_CLASS);
+   if (!source) return -1;
+
+   // FIXME: This is not true if the source is an evas image
+   *w = source->cur->geometry.w;
+   *h = source->cur->geometry.h;
+
+   EINA_LIST_FOREACH(ctx->buffers, li, fb)
+     {
+        if (pb->eo_source == fb->source)
+          {
+             if (fb->used) return -1;
+             if (fb->alpha_only) return -1;
+             if (!eina_streq(pb->name, fb->source_name)) return -1;
+             if ((*w != fb->w) || (*h != fb->h)) return -1;
+
+             fb->used = EINA_TRUE;
+             return fb->id;
+          }
+     }
+
+   fb = _buffer_empty_new(ctx, *w, *h, EINA_FALSE, EINA_FALSE);
+   if (!fb) return -1;
+
+   fb->source = efl_ref(pb->eo_source);
+   fb->source_name = eina_stringshare_add(pb->name);
+
+   fb->used = EINA_TRUE;
    return fb->id;
 }
 
@@ -351,6 +466,7 @@ _buffer_alloc_new(Evas_Filter_Context *ctx, int w, int h, Eina_Bool alpha_only,
    fb->w = w;
    fb->h = h;
    fb->alpha_only = alpha_only;
+   fb->is_render = render;
    fb->buffer = _ector_buffer_create(fb, render, draw);
    if (!fb->buffer)
      {
@@ -367,6 +483,8 @@ static void
 _buffer_free(Evas_Filter_Buffer *fb)
 {
    _filter_buffer_backing_free(fb);
+   eina_stringshare_del(fb->source_name);
+   efl_unref(fb->source);
    free(fb);
 }
 
@@ -434,6 +552,7 @@ _command_new(Evas_Filter_Context *ctx, Evas_Filter_Mode mode,
    if (output)
      {
         cmd->draw.output_was_dirty = output->dirty;
+        output->is_render = EINA_TRUE;
         output->dirty = EINA_TRUE;
      }
 
@@ -482,6 +601,7 @@ evas_filter_temporary_buffer_get(Evas_Filter_Context *ctx, int w, int h,
 
    fb = _buffer_empty_new(ctx, w, h, alpha_only, EINA_TRUE);
    fb->locked = EINA_TRUE;
+   fb->is_render = EINA_TRUE;
    XDBG("Created temporary buffer %d %s", fb->id, alpha_only ? "alpha" : "rgba");
 
    return fb;
@@ -1564,7 +1684,6 @@ _filter_chain_run(Evas_Filter_Context *ctx)
 
    DEBUG_TIME_BEGIN();
 
-   ctx->running = EINA_TRUE;
    EINA_INLIST_FOREACH(ctx->commands, cmd)
      {
         ok = _filter_command_run(cmd);
@@ -1646,7 +1765,7 @@ _filter_obscured_region_calc(Evas_Filter_Context *ctx)
 }
 
 Eina_Bool
-evas_filter_run(Evas_Filter_Context *ctx)
+evas_filter_context_run(Evas_Filter_Context *ctx)
 {
    Eina_Bool ret;
 
@@ -1657,12 +1776,14 @@ evas_filter_run(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);
         return EINA_TRUE;
      }
 
+   ctx->run_count++;
    ret = _filter_chain_run(ctx);
 
    if (ctx->post_run.cb)
diff --git a/src/lib/evas/filters/evas_filter_parser.c b/src/lib/evas/filters/evas_filter_parser.c
index 9c14e5dc06..60a7ecb476 100644
--- a/src/lib/evas/filters/evas_filter_parser.c
+++ b/src/lib/evas/filters/evas_filter_parser.c
@@ -2834,48 +2834,49 @@ evas_filter_program_parse(Evas_Filter_Program *pgm, const char *str)
 
 /** Run a program, must be already loaded */
 
-static void
+static Eina_Bool
 _buffers_update(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm)
 {
-   Evas_Object_Protected_Data *source;
    Evas_Filter_Proxy_Binding *pb;
-   Evas_Filter_Buffer *fb;
    Buffer *buf;
+   int w, h, id;
 
    EINA_INLIST_FOREACH(pgm->buffers, buf)
      {
         if (buf->proxy)
           {
              pb = eina_hash_find(pgm->proxies, buf->proxy);
-             if (!pb) continue;
-
-             buf->cid = evas_filter_buffer_empty_new(ctx, buf->alpha);
-             fb = _filter_buffer_get(ctx, buf->cid);
-             fb->source = pb->eo_source;
-             fb->source_name = eina_stringshare_ref(pb->name);
-             fb->ctx->has_proxies = EINA_TRUE;
-
-             source = efl_data_scope_get(fb->source, EFL_CANVAS_OBJECT_CLASS);
-             if ((source->cur->geometry.w != buf->w) ||
-                 (source->cur->geometry.h != buf->h))
-               pgm->changed = EINA_TRUE;
-             buf->w = fb->w = source->cur->geometry.w;
-             buf->h = fb->h = source->cur->geometry.h;
-             XDBG("Created proxy buffer %d %s '%s'", fb->id,
-                  buf->alpha ? "alpha" : "rgba", buf->name);
+             if (!pb) return EINA_FALSE;
+
+             ctx->has_proxies = EINA_TRUE;
+             id = evas_filter_buffer_proxy_new(ctx, pb, &w, &h);
+             if (id < 0) return EINA_FALSE;
+
+             buf->cid = id;
+             buf->w = w;
+             buf->h = h;
+
+             XDBG("Created proxy buffer #%d %dx%d %s '%s'", buf->cid,
+                  w, h, buf->alpha ? "alpha" : "rgba", buf->name);
           }
         else
           {
-             if ((buf->w != pgm->state.w) || (buf->h != pgm->state.h))
-               pgm->changed = EINA_TRUE;
-             buf->cid = evas_filter_buffer_empty_new(ctx, buf->alpha);
-             fb = _filter_buffer_get(ctx, buf->cid);
-             fb->w = buf->w = pgm->state.w;
-             fb->h = buf->h = pgm->state.h;
-             XDBG("Created context buffer %d %s '%s'", fb->id,
-                  buf->alpha ? "alpha" : "rgba", buf->name);
+             w = pgm->state.w;
+             h = pgm->state.h;
+
+             id = evas_filter_buffer_empty_new(ctx, w, h, buf->alpha);
+             if (id < 0) return EINA_FALSE;
+
+             buf->cid = id;
+             buf->w = w;
+             buf->h = h;
+
+             XDBG("Created context buffer #%d %dx%d %s '%s'", buf->cid,
+                  w, h, buf->alpha ? "alpha" : "rgba", buf->name);
           }
      }
+
+   return EINA_TRUE;
 }
 
 /** Evaluate required padding to correctly apply an effect */
@@ -3401,11 +3402,8 @@ _command_from_instruction(Evas_Filter_Context *ctx,
    cmd = instr2cmd(ctx, instr, dc);
    if (!cmd) return EINA_FALSE;
 
-   if (cmd->output && ctx->gl)
-     {
-        if (ENFN->gfx_filter_supports(ENDT, cmd) == EVAS_FILTER_SUPPORT_GL)
-          cmd->output->is_render = EINA_TRUE;
-     }
+   if (cmd->output)
+     cmd->output->is_render = EINA_TRUE;
 
    return EINA_TRUE;
 }
@@ -3475,7 +3473,8 @@ _instruction_dump(Evas_Filter_Instruction *instr)
 
 Eina_Bool
 evas_filter_context_program_use(Evas_Filter_Context *ctx,
-                                Evas_Filter_Program *pgm)
+                                Evas_Filter_Program *pgm,
+                                Eina_Bool reuse)
 {
    Evas_Filter_Instruction *instr;
    Eina_Bool success = EINA_FALSE;
@@ -3492,7 +3491,7 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
    ctx->h = pgm->state.h;
 
    // Create empty context with all required buffers
-   evas_filter_context_clear(ctx);
+   evas_filter_context_clear(ctx, reuse);
 
    if (pgm->changed)
      {
@@ -3508,7 +3507,9 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
              goto end;
           }
      }
-   _buffers_update(ctx, pgm);
+
+   // Create or update all buffers
+   if (!_buffers_update(ctx, pgm)) goto end;
 
    // Compute and save padding info
    evas_filter_program_padding_get(pgm, &ctx->pad.final, &ctx->pad.calculated);
@@ -3528,7 +3529,7 @@ evas_filter_context_program_use(Evas_Filter_Context *ctx,
    pgm->changed = EINA_FALSE;
 
 end:
-   if (!success) evas_filter_context_clear(ctx);
+   if (!success) evas_filter_context_clear(ctx, EINA_FALSE);
    if (dc) ENFN->context_free(ENDT, dc);
    return success;
 }
diff --git a/src/lib/evas/filters/evas_filter_private.h b/src/lib/evas/filters/evas_filter_private.h
index c62262a691..fb55aaf65e 100644
--- a/src/lib/evas/filters/evas_filter_private.h
+++ b/src/lib/evas/filters/evas_filter_private.h
@@ -157,10 +157,13 @@ struct _Evas_Filter_Context
       Eina_Bool color_use : 1;
    } target;
 
+   volatile int running;
+   int          run_count;
+
    Eina_Bool async : 1;
-   Eina_Bool running : 1;
    Eina_Bool has_proxies : 1;
    Eina_Bool gl : 1;
+
 };
 
 struct _Evas_Filter_Command
@@ -249,6 +252,7 @@ struct _Evas_Filter_Buffer
    Ector_Buffer *buffer;
    int w, h;
 
+   Eina_Bool used : 1;        // This buffer is in use (useful for reuse of context)
    Eina_Bool alpha_only : 1;  // 1 channel (A) instead of 4 (RGBA)
    Eina_Bool transient : 1;   // temporary buffer (automatic allocation)
    Eina_Bool locked : 1;      // internal flag
@@ -269,7 +273,7 @@ enum _Evas_Filter_Support
    EVAS_FILTER_SUPPORT_GL
 };
 
-void                     evas_filter_context_clear(Evas_Filter_Context *ctx);
+void                     evas_filter_context_clear(Evas_Filter_Context *ctx, Eina_Bool keep_buffers);
 void                     evas_filter_context_source_set(Evas_Filter_Context *ctx, Evas_Object *eo_proxy, Evas_Object *eo_source, int bufid, Eina_Stringshare *name);
 
 /* Utility functions */
diff --git a/src/lib/evas/include/evas_filter.h b/src/lib/evas/include/evas_filter.h
index c6854fd3c4..edb12cdcde 100644
--- a/src/lib/evas/include/evas_filter.h
+++ b/src/lib/evas/include/evas_filter.h
@@ -32,7 +32,6 @@
 # endif
 #endif /* ! _WIN32 */
 
-typedef struct _Evas_Filter_Context Evas_Filter_Context;
 typedef struct _Evas_Filter_Instruction Evas_Filter_Instruction;
 typedef struct _Evas_Filter_Buffer Evas_Filter_Buffer;
 typedef struct _Evas_Filter_Proxy_Binding Evas_Filter_Proxy_Binding;
@@ -146,19 +145,22 @@ void                     evas_filter_program_data_set_all(Evas_Filter_Program *p
 Evas_Filter_Context     *evas_filter_context_new(Evas_Public_Data *evas, Eina_Bool async, void *user_data);
 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                evas_filter_context_program_use(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm, Eina_Bool reuse);
+Eina_Bool                evas_filter_context_program_reuse(Evas_Filter_Context *ctx, Evas_Filter_Program *pgm);
 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)
 Eina_Bool                evas_filter_context_buffers_allocate_all(Evas_Filter_Context *ctx);
 void                     evas_filter_context_obscured_region_set(Evas_Filter_Context *ctx, Eina_Rectangle rect);
 
-int                      evas_filter_buffer_empty_new(Evas_Filter_Context *ctx, Eina_Bool alpha_only);
+int                      evas_filter_buffer_empty_new(Evas_Filter_Context *ctx, int w, int h, Eina_Bool alpha_only);
+int                      evas_filter_buffer_proxy_new(Evas_Filter_Context *ctx, Evas_Filter_Proxy_Binding *pb, int *w, int *h);
 void                    *evas_filter_buffer_backing_get(Evas_Filter_Context *ctx, int bufid, Eina_Bool render);
 Eina_Bool                evas_filter_buffer_backing_release(Evas_Filter_Context *ctx, void *stolen_buffer);
 
-Eina_Bool                evas_filter_run(Evas_Filter_Context *ctx);
+Eina_Bool                evas_filter_context_run(Evas_Filter_Context *ctx);
 
 Eina_Bool                evas_filter_font_draw(Evas_Filter_Context *ctx, 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);
diff --git a/src/lib/evas/include/evas_private.h b/src/lib/evas/include/evas_private.h
index cd5683817b..6a0c77686c 100644
--- a/src/lib/evas/include/evas_private.h
+++ b/src/lib/evas/include/evas_private.h
@@ -93,6 +93,7 @@ typedef struct _Evas_Object_Protected_Data  Evas_Object_Protected_Data;
 
 /* gfx filters typedef only */
 typedef struct _Evas_Filter_Program         Evas_Filter_Program;
+typedef struct _Evas_Filter_Context         Evas_Filter_Context;
 typedef struct _Evas_Object_Filter_Data     Evas_Object_Filter_Data;
 typedef struct _Evas_Filter_Data_Binding    Evas_Filter_Data_Binding;
 typedef struct _Evas_Pointer_Data           Evas_Pointer_Data;
@@ -1288,6 +1289,7 @@ struct _Evas_Object_Filter_Data
    Eina_Stringshare    *name;
    Eina_Stringshare    *code;
    Evas_Filter_Program *chain;
+   Evas_Filter_Context *context;
    Eina_Hash           *sources; // Evas_Filter_Proxy_Binding
    Eina_Inlist         *data; // Evas_Filter_Data_Binding
    Eina_Rectangle       prev_obscured, obscured;
@@ -1306,6 +1308,7 @@ struct _Evas_Object_Filter_Data
    Eina_Bool            changed : 1;
    Eina_Bool            invalid : 1; // Code parse failed
    Eina_Bool            async : 1;
+   Eina_Bool            reuse : 1;
 };
 
 struct _Evas_Object_Func