ector: code refactoring.

Current vector drawing requires several methods for compositing,
it's shouldnt have only masking but other blending functions
such as matte in lottie, porter&duff in android, etc.

Previously we didn't specify this method name,
just reserved the options and now we started to define the methods
with ector_renderer_composite_method() with Efl.Gfx.VG_Composite_Method
instead of mask_set().

21 files changed, 258 insertions, 293 deletions

diff --git a/src/lib/ector/ector_renderer.c b/src/lib/ector/ector_renderer.c
index d0efab6a6c..15bd96e627 100644
--- a/src/lib/ector/ector_renderer.c
+++ b/src/lib/ector/ector_renderer.c
@@ -146,10 +146,10 @@ _ector_renderer_crc_get(const Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_mask_set(Eo *obj EINA_UNUSED,
-                         Ector_Renderer_Data *pd EINA_UNUSED,
-                         Ector_Buffer *mask EINA_UNUSED,
-                         int op EINA_UNUSED)
+_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
+                                Ector_Renderer_Data *pd EINA_UNUSED,
+                                Ector_Buffer *comp EINA_UNUSED,
+                                Efl_Gfx_Vg_Composite_Method method EINA_UNUSED)
 {
 }
 
diff --git a/src/lib/ector/ector_renderer.eo b/src/lib/ector/ector_renderer.eo
index 4d7279aebd..74d0f8bd43 100644
--- a/src/lib/ector/ector_renderer.eo
+++ b/src/lib/ector/ector_renderer.eo
@@ -78,13 +78,13 @@ abstract @beta Ector.Renderer extends Efl.Object
             return: uint; [[CRC value]]
          }
       }
-      @property mask {
-         [[Set Mask Image to this Renderer]]
+      @property comp_method {
+         [[Set Composite Buffer to this Renderer]]
          set {
          }
          values {
-            mask: Ector.Buffer; [[Mask Image Buffer]]
-            op: int; [[Masking option]]
+            comp: Ector.Buffer; [[Composite Buffer]]
+            method: Efl.Gfx.Vg_Composite_Method; [[Composite method]]
          }
       }
       draw @pure_virtual {
diff --git a/src/lib/ector/software/ector_renderer_software_image.c b/src/lib/ector/software/ector_renderer_software_image.c
index cb8d93ad6c..e06e79d574 100644
--- a/src/lib/ector/software/ector_renderer_software_image.c
+++ b/src/lib/ector/software/ector_renderer_software_image.c
@@ -21,10 +21,10 @@ struct _Ector_Renderer_Software_Image_Data
    Ector_Software_Surface_Data *surface;
    Ector_Renderer_Image_Data   *image;
    Ector_Renderer_Data         *base;
-   Ector_Buffer                *mask;
-   int                          mask_op;
-   int                         opacity;
-   Eina_Matrix3                inv_m;
+   Ector_Buffer                *comp;
+   Efl_Gfx_Vg_Composite_Method comp_method;
+   int                          opacity;
+   Eina_Matrix3                 inv_m;
    struct {
       int x1, y1, x2, y2;
    } boundary;
@@ -101,7 +101,7 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED,
       return EINA_TRUE;
 
    const int pix_stride = pd->surface->rasterizer->fill_data.raster_buffer->stride / 4;
-   Ector_Software_Buffer_Base_Data *mask = pd->mask ? efl_data_scope_get(pd->mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
+   Ector_Software_Buffer_Base_Data *comp = pd->comp ? efl_data_scope_get(pd->comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
    Ector_Software_Buffer_Base_Data *bpd = efl_data_scope_get(pd->image->buffer, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
    double im11, im12, im21, im22, im31, im32;
    uint32_t *dst_buf, *src_buf;
@@ -128,10 +128,10 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED,
                continue;
              uint32_t *src = src_buf + (rx + (ry * image_w));  //FIXME: use to stride
              uint32_t temp = 0x0;
-             if (mask)
+             if (comp)
                {
-                  uint32_t *m = mask->pixels.u32 + ((int)local_x + ((int)local_y * mask->generic->w));
-                  //FIXME : This masking can work only matte case.
+                  uint32_t *m = comp->pixels.u32 + ((int)local_x + ((int)local_y * comp->generic->w));
+                  //FIXME : This comping can work only matte case.
                   //        We need consider to inverse matte case.
                   temp = draw_mul_256((((*m)>>24) * pd->opacity)>>8, *src);
                }
@@ -182,13 +182,13 @@ _ector_renderer_software_image_ector_renderer_crc_get(const Eo *obj,
 }
 
 static void
-_ector_renderer_software_image_ector_renderer_mask_set(Eo *obj EINA_UNUSED,
-                                                       Ector_Renderer_Software_Image_Data *pd,
-                                                       Ector_Buffer *mask,
-                                                       int op)
+_ector_renderer_software_image_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
+                                                              Ector_Renderer_Software_Image_Data *pd,
+                                                              Ector_Buffer *comp,
+                                                              Efl_Gfx_Vg_Composite_Method method)
 {
-   pd->mask = mask;
-   pd->mask_op = op;
+   pd->comp = comp;
+   pd->comp_method = method;
 }
 
 #include "ector_renderer_software_image.eo.c"
diff --git a/src/lib/ector/software/ector_renderer_software_image.eo b/src/lib/ector/software/ector_renderer_software_image.eo
index 8a3f9c51e7..477170242b 100644
--- a/src/lib/ector/software/ector_renderer_software_image.eo
+++ b/src/lib/ector/software/ector_renderer_software_image.eo
@@ -5,7 +5,7 @@ class @beta Ector.Renderer.Software.Image extends Ector.Renderer.Software implem
    implements {
       Ector.Renderer.prepare;
       Ector.Renderer.draw;
-      Ector.Renderer.mask { set; }
+      Ector.Renderer.comp_method { set; }
       Ector.Renderer.crc { get; }
       Efl.Object.constructor;
       Efl.Object.destructor;
diff --git a/src/lib/ector/software/ector_renderer_software_shape.c b/src/lib/ector/software/ector_renderer_software_shape.c
index 6210179b03..601d03cf9f 100644
--- a/src/lib/ector/software/ector_renderer_software_shape.c
+++ b/src/lib/ector/software/ector_renderer_software_shape.c
@@ -38,8 +38,8 @@ struct _Ector_Renderer_Software_Shape_Data
    Shape_Rle_Data              *shape_data;
    Shape_Rle_Data              *outline_data;
 
-   Ector_Buffer                *mask;
-   int                          mask_op;
+   Ector_Buffer                *comp;
+   Efl_Gfx_Vg_Composite_Method comp_method;
 
    Ector_Software_Shape_Task   *task;
 
@@ -675,8 +675,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
         ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
                                                 x, y, mul_col, op,
                                                 pd->shape_data,
-                                                pd->mask,
-                                                pd->mask_op);
+                                                pd->comp,
+                                                pd->comp_method);
      }
    else
      {
@@ -690,8 +690,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
              ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
                                                      x, y, mul_col, op,
                                                      pd->shape_data,
-                                                     pd->mask,
-                                                     pd->mask_op);
+                                                     pd->comp,
+                                                     pd->comp_method);
           }
      }
 
@@ -703,8 +703,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
         ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
                                                 x, y, mul_col, op,
                                                 pd->outline_data,
-                                                pd->mask,
-                                                pd->mask_op);
+                                                pd->comp,
+                                                pd->comp_method);
      }
    else
      {
@@ -718,8 +718,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
              ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
                                                      x, y, mul_col, op,
                                                      pd->outline_data,
-                                                     pd->mask,
-                                                     pd->mask_op);
+                                                     pd->comp,
+                                                     pd->comp_method);
           }
      }
 
@@ -829,14 +829,14 @@ _ector_renderer_software_shape_ector_renderer_crc_get(const Eo *obj,
 }
 
 static void
-_ector_renderer_software_shape_ector_renderer_mask_set(Eo *obj EINA_UNUSED,
-                                                       Ector_Renderer_Software_Shape_Data *pd,
-                                                       Ector_Buffer *mask,
-                                                       int op)
+_ector_renderer_software_shape_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
+                                                              Ector_Renderer_Software_Shape_Data *pd,
+                                                              Ector_Buffer *comp,
+                                                              Efl_Gfx_Vg_Composite_Method method)
 {
    //Use ref/unref.
-   pd->mask = mask;
-   pd->mask_op = op;
+   pd->comp = comp;
+   pd->comp_method = method;
 }
 
 #include "ector_renderer_software_shape.eo.c"
diff --git a/src/lib/ector/software/ector_renderer_software_shape.eo b/src/lib/ector/software/ector_renderer_software_shape.eo
index 4ea56f9260..83b87c0121 100644
--- a/src/lib/ector/software/ector_renderer_software_shape.eo
+++ b/src/lib/ector/software/ector_renderer_software_shape.eo
@@ -6,7 +6,7 @@ class @beta Ector.Renderer.Software.Shape extends Ector.Renderer.Software implem
       Ector.Renderer.prepare;
       Ector.Renderer.draw;
       Ector.Renderer.Software.op_fill;
-      Ector.Renderer.mask { set; }
+      Ector.Renderer.comp_method { set; }
       Ector.Renderer.crc { get; }
       Efl.Gfx.Path.commit;
       Efl.Object.constructor;
diff --git a/src/lib/ector/software/ector_software_private.h b/src/lib/ector/software/ector_software_private.h
index f7e47fed22..24fe240f58 100644
--- a/src/lib/ector/software/ector_software_private.h
+++ b/src/lib/ector/software/ector_software_private.h
@@ -83,8 +83,8 @@ typedef struct _Span_Data
 
    int              offx, offy;
    Clip_Data        clip;
-   Ector_Software_Buffer_Base_Data    *mask;
-   int mask_op;
+   Ector_Software_Buffer_Base_Data    *comp;
+   Efl_Gfx_Vg_Composite_Method comp_method;
    Eina_Matrix3     inv;
    Span_Data_Type   type;
    Eina_Bool        fast_matrix;
@@ -136,8 +136,8 @@ void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
                                              int x, int y, uint32_t mul_col,
                                              Efl_Gfx_Render_Op op,
                                              Shape_Rle_Data* rle,
-                                             Ector_Buffer *mask,
-                                             int mask_op);
+                                             Ector_Buffer *comp,
+                                             Efl_Gfx_Vg_Composite_Method comp_method);
 
 void ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle);
 
diff --git a/src/lib/ector/software/ector_software_rasterizer.c b/src/lib/ector/software/ector_software_rasterizer.c
index ad4aa25e70..8cd085432a 100644
--- a/src/lib/ector/software/ector_software_rasterizer.c
+++ b/src/lib/ector/software/ector_software_rasterizer.c
@@ -11,21 +11,6 @@
 
 #include "draw.h"
 
-//FIXME: This enum add temporarily to help understanding of additional code
-//related to masking in prepare_mask.
-//This needs to be formally declared through the eo class.
-typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE
-{
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE
-}EFL_CANVAS_VG_NODE_BLEND_TYPE;
-//
-
 static void
 _blend_argb(int count, const SW_FT_Span *spans, void *user_data)
 {
@@ -49,12 +34,12 @@ _blend_argb(int count, const SW_FT_Span *spans, void *user_data)
 }
 
 static void
-_blend_alpha(int count, const SW_FT_Span *spans, void *user_data)
+_comp_matte_alpha(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
    const int pix_stride = sd->raster_buffer->stride / 4;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    // multiply the color with mul_col if any
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
@@ -63,7 +48,7 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data)
    // move to the offset location
    uint32_t *buffer =
          sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    //Temp buffer for intermediate processing
    int tsize = sd->raster_buffer->generic->w;
@@ -73,12 +58,12 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data)
      {
         uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x);
         uint32_t *mtarget =
-              mbuffer + ((mask->generic->w * spans->y) + spans->x);
+              mbuffer + ((comp->generic->w * spans->y) + spans->x);
         uint32_t *temp = tbuffer;
         memset(temp, 0x00, sizeof(uint32_t) * spans->len);
         comp_func(temp, spans->len, color, spans->coverage);
 
-        //masking
+        //composite
         for (int i = 0; i < spans->len; i++)
           {
              *temp = draw_mul_256(((*mtarget)>>24), *temp);
@@ -93,12 +78,12 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data)
 }
 
 static void
-_blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
+_comp_matte_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
    const int pix_stride = sd->raster_buffer->stride / 4;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    // multiply the color with mul_col if any
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
@@ -107,7 +92,7 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
    // move to the offset location
    uint32_t *buffer =
          sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    //Temp buffer for intermediate processing
    int tsize = sd->raster_buffer->generic->w;
@@ -117,12 +102,12 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
      {
         uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x);
         uint32_t *mtarget =
-              mbuffer + ((mask->generic->w * spans->y) + spans->x);
+              mbuffer + ((comp->generic->w * spans->y) + spans->x);
         uint32_t *temp = tbuffer;
         memset(temp, 0x00, sizeof(uint32_t) * spans->len);
         comp_func(temp, spans->len, color, spans->coverage);
 
-        //masking
+        //composite
         for (int i = 0; i < spans->len; i++)
           {
              if (*mtarget)
@@ -138,22 +123,22 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
 }
 
 static void
-_blend_mask_add(int count, const SW_FT_Span *spans, void *user_data)
+_comp_mask_add(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
    RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    int tsize = sd->raster_buffer->generic->w;
    uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
 
    while (count--)
      {
-        uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+        uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
         memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
         comp_func(ttarget, spans->len, color, spans->coverage);
         for (int i = 0; i < spans->len; i++)
@@ -163,22 +148,22 @@ _blend_mask_add(int count, const SW_FT_Span *spans, void *user_data)
 }
 
 static void
-_blend_mask_sub(int count, const SW_FT_Span *spans, void *user_data)
+_comp_mask_sub(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
    RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    int tsize = sd->raster_buffer->generic->w;
    uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
 
    while (count--)
      {
-        uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+        uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
         memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
         comp_func(ttarget, spans->len, color, spans->coverage);
         for (int i = 0; i < spans->len; i++)
@@ -189,28 +174,28 @@ _blend_mask_sub(int count, const SW_FT_Span *spans, void *user_data)
 
 
 static void
-_blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data)
+_comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
    RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    int tsize = sd->raster_buffer->generic->w;
    uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
 
-   for(unsigned int y = 0; y < mask->generic->h; y++)
+   for(unsigned int y = 0; y < comp->generic->h; y++)
      {
-        for(unsigned int x = 0; x < mask->generic->w; x++)
+        for(unsigned int x = 0; x < comp->generic->w; x++)
           {
-             if (x == (unsigned int)spans->x && x + spans->len <= mask->generic->w &&
+             if (x == (unsigned int)spans->x && x + spans->len <= comp->generic->w &&
                  y == (unsigned int)spans->y && count > 0)
                {
                   memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
-                  uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+                  uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
                   comp_func(ttarget, spans->len, color, spans->coverage);
                   for (int c = 0; c < spans->len; c++)
                     mtarget[c] = draw_mul_256(ttarget[c]>>24, mtarget[c]);
@@ -220,7 +205,7 @@ _blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data)
                }
              else
                {
-                  mbuffer[x + (mask->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (mask->generic->w * y)]);
+                  mbuffer[x + (comp->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (comp->generic->w * y)]);
                }
           }
      }
@@ -228,15 +213,15 @@ _blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data)
 
 
 static void
-_blend_mask_diff(int count, const SW_FT_Span *spans, void *user_data)
+_comp_mask_diff(int count, const SW_FT_Span *spans, void *user_data)
 {
    Span_Data *sd = user_data;
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   if (!mask || !mask->pixels.u32) return;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   if (!comp || !comp->pixels.u32) return;
 
    uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
    RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color);
-   uint32_t *mbuffer = mask->pixels.u32;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    int tsize = sd->raster_buffer->generic->w;
    uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
@@ -244,7 +229,7 @@ _blend_mask_diff(int count, const SW_FT_Span *spans, void *user_data)
    while (count--)
      {
         memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
-        uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+        uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
         comp_func(ttarget, spans->len, color, spans->coverage);
         for (int i = 0; i < spans->len; i++)
           mtarget[i] = draw_mul_256(0xFF - (mtarget[i]>>24), ttarget[i]) + draw_mul_256(0xFF - (ttarget[i]>>24), mtarget[i]);
@@ -309,8 +294,8 @@ _blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data)
 
    if (!fetchfunc) return;
 
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   uint32_t *mbuffer = mask->pixels.u32;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    // move to the offset location
    buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx);
@@ -318,7 +303,7 @@ _blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data)
    while (count--)
      {
         uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x);
-        uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+        uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
         int length = spans->len;
 
         while (length)
@@ -358,8 +343,8 @@ _blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
 
    if (!fetchfunc) return;
 
-   Ector_Software_Buffer_Base_Data *mask = sd->mask;
-   uint32_t *mbuffer = mask->pixels.u32;
+   Ector_Software_Buffer_Base_Data *comp = sd->comp;
+   uint32_t *mbuffer = comp->pixels.u32;
 
    // move to the offset location
    buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx);
@@ -367,7 +352,7 @@ _blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
    while (count--)
      {
         uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x);
-        uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x);
+        uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x);
         int length = spans->len;
 
         while (length)
@@ -584,38 +569,38 @@ static void
 _adjust_span_fill_methods(Span_Data *spdata)
 {
    //Blending Function
-   if (spdata->mask)
+   if (spdata->comp)
      {
-        switch (spdata->mask_op)
+        switch (spdata->comp_method)
           {
            default:
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA:
+           case EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA:
               if (spdata->type == Solid)
-                spdata->unclipped_blend = &_blend_alpha;
+                spdata->unclipped_blend = &_comp_matte_alpha;
               else if (spdata->type == LinearGradient || spdata->type == RadialGradient)
                 spdata->unclipped_blend = &_blend_gradient_alpha;
               else //None
                 spdata->unclipped_blend = NULL;
               break;
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV:
+           case EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE:
               if (spdata->type == Solid)
-                spdata->unclipped_blend = &_blend_alpha_inv;
+                spdata->unclipped_blend = &_comp_matte_alpha_inv;
               else if (spdata->type == LinearGradient || spdata->type == RadialGradient)
                 spdata->unclipped_blend = &_blend_gradient_alpha_inv;
               else //None
                 spdata->unclipped_blend = NULL;
               break;
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD:
-              spdata->unclipped_blend = &_blend_mask_add;
+           case EFL_GFX_VG_COMPOSITE_METHOD_MASK_ADD:
+              spdata->unclipped_blend = &_comp_mask_add;
               break;
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT:
-              spdata->unclipped_blend = &_blend_mask_sub;
+           case EFL_GFX_VG_COMPOSITE_METHOD_MASK_SUBSTRACT:
+              spdata->unclipped_blend = &_comp_mask_sub;
               break;
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT:
-              spdata->unclipped_blend = &_blend_mask_ins;
+           case EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT:
+              spdata->unclipped_blend = &_comp_mask_ins;
               break;
-           case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE:
-              spdata->unclipped_blend = &_blend_mask_diff;
+           case EFL_GFX_VG_COMPOSITE_METHOD_MASK_DIFFERENCE:
+              spdata->unclipped_blend = &_comp_mask_diff;
               break;
           }
      }
@@ -895,8 +880,8 @@ void
 ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
                                         int x, int y, uint32_t mul_col,
                                         Efl_Gfx_Render_Op op, Shape_Rle_Data* rle,
-                                        Ector_Buffer *mask,
-                                        int mask_op)
+                                        Ector_Buffer *comp,
+                                        Efl_Gfx_Vg_Composite_Method comp_method)
 {
    if (!rle) return;
    if (!rasterizer->fill_data.raster_buffer->pixels.u32) return;
@@ -905,9 +890,9 @@ ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
    rasterizer->fill_data.offy = y;
    rasterizer->fill_data.mul_col = mul_col;
    rasterizer->fill_data.op = op;
-   rasterizer->fill_data.mask =
-         mask ? efl_data_scope_get(mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
-   rasterizer->fill_data.mask_op = mask_op;
+   rasterizer->fill_data.comp =
+         comp ? efl_data_scope_get(comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
+   rasterizer->fill_data.comp_method = comp_method;
 
    _setup_span_fill_matrix(rasterizer);
    _adjust_span_fill_methods(&rasterizer->fill_data);
diff --git a/src/lib/efl/interfaces/efl_gfx_types.eot b/src/lib/efl/interfaces/efl_gfx_types.eot
index 0f2954b954..ecc0588b1d 100644
--- a/src/lib/efl/interfaces/efl_gfx_types.eot
+++ b/src/lib/efl/interfaces/efl_gfx_types.eot
@@ -141,6 +141,17 @@ struct @beta Efl.Gfx.Shape_Public
    stroke: Efl.Gfx.Stroke; [[Internal representation as stroke]]
 }
 
+enum @beta Efl.Gfx.Vg_Composite_Method
+{
+   none,
+   matte_alpha,
+   matte_alpha_inverse,
+   mask_add,
+   mask_substract,
+   mask_intersect,
+   mask_difference
+}
+
 enum @beta Efl.Gfx.Border_Fill_Mode
 {
    [[How an image's center region (the complement to the border region) should be rendered by EFL]]
diff --git a/src/lib/evas/canvas/efl_canvas_vg_container.c b/src/lib/evas/canvas/efl_canvas_vg_container.c
index 2daa65fb80..e265e33e11 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_container.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_container.c
@@ -5,23 +5,6 @@
 
 #define MY_CLASS EFL_CANVAS_VG_CONTAINER_CLASS
 
-
-//FIXME: This enum add temporarily to help understanding of additional code
-//related to masking in prepare_mask.
-//This needs to be formally declared through the eo class.
-//This is a list of blending supported via efl_canvas_vg_node_mask_set().
-typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE
-{
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE
-}EFL_CANVAS_VG_NODE_BLEND_TYPE;
-//
-
 static void
 _invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event)
 {
@@ -40,7 +23,7 @@ _invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 static void
-_draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
+_draw_comp(Evas_Object_Protected_Data *obj, Efl_VG *node,
            Ector_Surface *ector, void *engine, void *output,
            void *context)
 {
@@ -51,11 +34,11 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
         Efl_Canvas_Vg_Container_Data *cd =
            efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS);
 
-        //Draw Mask Image.
+        //Draw Composite Image.
         Efl_VG *child;
         Eina_List *l;
         EINA_LIST_FOREACH(cd->children, l, child)
-          _draw_mask(obj, child, ector, engine, output, context);
+          _draw_comp(obj, child, ector, engine, output, context);
      }
    else
      {
@@ -65,93 +48,94 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
 }
 
 static Ector_Buffer *
-_prepare_mask(Evas_Object_Protected_Data *obj,     //vector object
-              Efl_Canvas_Vg_Node* mask_obj,
+_prepare_comp(Evas_Object_Protected_Data *obj,     //vector object
+              Efl_Canvas_Vg_Node* comp_target,
               void *engine, void *output, void *context,
               Ector_Surface *surface,
               Eina_Matrix3 *ptransform,
               Eina_Matrix3 *ctransform,
-              Ector_Buffer *mask,
-              int mask_op)
+              Ector_Buffer *comp,
+              Efl_Gfx_Vg_Composite_Method comp_method)
 {
-   Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(mask_obj, MY_CLASS);
+   Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(comp_target, MY_CLASS);
    Efl_Canvas_Vg_Node_Data *nd =
-         efl_data_scope_get(mask_obj, EFL_CANVAS_VG_NODE_CLASS);
-   if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->mask.buffer;
+         efl_data_scope_get(comp_target, EFL_CANVAS_VG_NODE_CLASS);
+   if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->comp.buffer;
    uint32_t init_buffer = 0x0;
 
-   //1. Mask Size
+   //1. Composite Size
    Eina_Rect mbound;
    mbound.x = 0;
    mbound.y = 0;
    mbound.w = obj->cur->geometry.w;
    mbound.h = obj->cur->geometry.h;
 
-   //FIXME: If mask typs is SUBSTRACT or INTERSECT, buffer fills in white color(Full alpha color).
-   if (pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT || pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT)
+   //FIXME: If composite method is SUBSTRACT or INTERSECT, buffer fills in white color(Full alpha color).
+   if (pd->comp.method == EFL_GFX_VG_COMPOSITE_METHOD_MASK_SUBSTRACT ||
+       pd->comp.method == EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT)
      init_buffer = 0xFFFFFFFF;
 
    //2. Reusable ector buffer?
-   if (!pd->mask.buffer || (pd->mask.bound.w != mbound.w) ||
-         (pd->mask.bound.h != mbound.h))
+   if (!pd->comp.buffer || (pd->comp.bound.w != mbound.w) ||
+         (pd->comp.bound.h != mbound.h))
      {
-        if (pd->mask.pixels) free(pd->mask.pixels);
-        if (pd->mask.buffer) efl_unref(pd->mask.buffer);
-        pd->mask.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h));
-        memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h));
-        pd->mask.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas,
+        if (pd->comp.pixels) free(pd->comp.pixels);
+        if (pd->comp.buffer) efl_unref(pd->comp.buffer);
+        pd->comp.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h));
+        memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h));
+        pd->comp.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas,
                                                  mbound.w, mbound.h,
                                                  EFL_GFX_COLORSPACE_ARGB8888,
                                                  ECTOR_BUFFER_FLAG_DRAWABLE |
                                                  ECTOR_BUFFER_FLAG_CPU_READABLE |
                                                  ECTOR_BUFFER_FLAG_CPU_WRITABLE);
-        ector_buffer_pixels_set(pd->mask.buffer, pd->mask.pixels,
+        ector_buffer_pixels_set(pd->comp.buffer, pd->comp.pixels,
                                 mbound.w, mbound.h, 0,
                                 EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
-        pd->mask.bound.w = mbound.w;
-        pd->mask.bound.h = mbound.h;
-        pd->mask.vg_pd = obj;
+        pd->comp.bound.w = mbound.w;
+        pd->comp.bound.h = mbound.h;
+        pd->comp.vg_pd = obj;
      }
    else
      {
-        if (pd->mask.pixels)
-          memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h);
+        if (pd->comp.pixels)
+          memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h);
      }
 
-   pd->mask.bound.x = mbound.x;
-   pd->mask.bound.y = mbound.y;
+   pd->comp.bound.x = mbound.x;
+   pd->comp.bound.y = mbound.y;
 
-   if (!pd->mask.buffer) ERR("Mask Buffer is invalid");
+   if (!pd->comp.buffer) ERR("Composite Buffer is invalid");
 
-   //FIXME: This code means that there is another masking container.
-   if (pd->mask.option >= EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD)
+   //FIXME: This code means that there is another composite container.
+   if (pd->comp.method >= EFL_GFX_VG_COMPOSITE_METHOD_MASK_ADD)
      {
-        Efl_Canvas_Vg_Container_Data *src_pd = pd;
-        mask = pd->mask.buffer;
-        for (Efl_VG *mask_src = pd->mask_src; mask_src; mask_src = src_pd->mask_src)
+        Efl_Canvas_Vg_Container_Data *target_pd = pd;
+        comp = pd->comp.buffer;
+        for (Efl_VG *comp_target = pd->comp_target; comp_target; comp_target = target_pd->comp_target)
           {
-             Efl_Canvas_Vg_Container_Data *target_pd = NULL;
-             src_pd = efl_data_scope_get(mask_src, MY_CLASS);
-             target_pd = efl_data_scope_get(eina_list_nth(src_pd->mask.target, 0), MY_CLASS);
-             _evas_vg_render_pre(obj, mask_src,
+             Efl_Canvas_Vg_Container_Data *src_pd = NULL;
+             target_pd = efl_data_scope_get(comp_target, MY_CLASS);
+             src_pd = efl_data_scope_get(eina_list_nth(target_pd->comp.src, 0), MY_CLASS);
+             _evas_vg_render_pre(obj, comp_target,
                                  engine, output, context, surface,
-                                 ctransform, mask, target_pd->mask.option);
+                                 ctransform, comp, src_pd->comp.method);
           }
      }
 
    //3. Prepare Drawing shapes.
-   _evas_vg_render_pre(obj, mask_obj,
+   _evas_vg_render_pre(obj, comp_target,
                        engine, output, context,
                        surface,
-                       ptransform, mask, mask_op);
+                       ptransform, comp, comp_method);
 
-   //4. Generating Mask Image.
-   ector_buffer_pixels_set(surface, pd->mask.pixels, mbound.w, mbound.h, 0,
+   //4. Generating Composite Image.
+   ector_buffer_pixels_set(surface, pd->comp.pixels, mbound.w, mbound.h, 0,
                            EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
    ector_surface_reference_point_set(surface, -mbound.x, -mbound.y);
-   _draw_mask(obj, mask_obj, surface, engine, output, context);
+   _draw_comp(obj, comp_target, surface, engine, output, context);
 
-   return pd->mask.buffer;
+   return pd->comp.buffer;
 }
 
 static void
@@ -161,8 +145,8 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
                                     void *engine, void *output, void *context,
                                     Ector_Surface *surface,
                                     Eina_Matrix3 *ptransform,
-                                    Ector_Buffer *mask,
-                                    int mask_op,
+                                    Ector_Buffer *comp,
+                                    Efl_Gfx_Vg_Composite_Method comp_method,
                                     void *data)
 {
    Efl_Canvas_Vg_Container_Data *pd = data;
@@ -177,27 +161,27 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
 
    EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd);
 
-   //Container may have mask source.
-   //FIXME : _prepare_mask() should only work in cases with matte or main mask.
-   // This condition is valid because the main mask use same type as matte alpha.
-   if (pd->mask_src &&
-       (pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA ||
-        pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV))
+   //Container may have composite target.
+   //FIXME : _prepare_comp() should only work in cases with matte or masking.
+   // This condition is valid because the masking use same type as matte.
+   if (pd->comp_target &&
+       (pd->comp.method == EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA ||
+        pd->comp.method == EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE))
      {
-        mask_op = pd->mask.option;
-        mask = _prepare_mask(vg_pd, pd->mask_src,
+        comp_method = pd->comp.method;
+        comp = _prepare_comp(vg_pd, pd->comp_target,
                              engine, output, context, surface,
-                             ptransform, ctransform, mask, mask_op);
+                             ptransform, ctransform, comp, comp_method);
      }
 
    EINA_LIST_FOREACH(pd->children, l, child)
      {
-        //Don't need to update mask nodes.
+        //Don't need to update composite nodes.
         if (efl_isa(child, MY_CLASS))
           {
              Efl_Canvas_Vg_Container_Data *child_cd =
                 efl_data_scope_get(child, MY_CLASS);
-             if (child_cd->mask.target) continue;
+             if (child_cd->comp.src) continue;
           }
 
         //Skip Gradients. they will be updated by Shape.
@@ -212,7 +196,7 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
 
         _evas_vg_render_pre(vg_pd, child,
                             engine, output, context, surface,
-                            ctransform, mask, mask_op);
+                            ctransform, comp, comp_method);
      }
 }
 
@@ -243,12 +227,12 @@ _efl_canvas_vg_container_efl_object_destructor(Eo *obj,
    if (pd->blend_pixels) free(pd->blend_pixels);
    if (pd->blend_buffer) efl_unref(pd->blend_buffer);
 
-   //Destroy mask surface
-   if (pd->mask.buffer) efl_unref(pd->mask.buffer);
-   if (pd->mask.pixels) free(pd->mask.pixels);
+   //Destroy comp surface
+   if (pd->comp.buffer) efl_unref(pd->comp.buffer);
+   if (pd->comp.pixels) free(pd->comp.pixels);
 
-   efl_unref(pd->mask_src);
-   eina_list_free(pd->mask.target);
+   efl_unref(pd->comp_target);
+   eina_list_free(pd->comp.src);
    eina_hash_free(pd->names);
 
    efl_destructor(efl_super(obj, MY_CLASS));
@@ -333,14 +317,14 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain
         if (!r) break;
      }
 
-   //Interpolates Mask
+   //Interpolates Composite
    Efl_Canvas_Vg_Container_Data *fromd = efl_data_scope_get(from, MY_CLASS);
    Efl_Canvas_Vg_Container_Data *tod = efl_data_scope_get(to, MY_CLASS);
 
-   if (fromd->mask_src && tod->mask_src && pd->mask_src)
+   if (fromd->comp_target && tod->comp_target && pd->comp_target)
      {
-        if (!efl_gfx_path_interpolate(pd->mask_src,
-                                      fromd->mask_src, tod->mask_src, pos_map))
+        if (!efl_gfx_path_interpolate(pd->comp_target,
+                                      fromd->comp_target, tod->comp_target, pos_map))
           return EINA_FALSE;
      }
 
@@ -351,30 +335,30 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain
 }
 
 static void
-_efl_canvas_vg_container_efl_canvas_vg_node_mask_set(Eo *obj,
-                                                     Efl_Canvas_Vg_Container_Data *pd,
-                                                     Efl_Canvas_Vg_Node *mask,
-                                                     int op)
+_efl_canvas_vg_container_efl_canvas_vg_node_comp_method_set(Eo *obj,
+                                                            Efl_Canvas_Vg_Container_Data *pd,
+                                                            Efl_Canvas_Vg_Node *target,
+                                                            Efl_Gfx_Vg_Composite_Method method)
 {
-   if (pd->mask_src == mask) return;
+   if (pd->comp_target == target) return;
 
-   EINA_SAFETY_ON_FALSE_RETURN(efl_isa(mask, MY_CLASS));
+   EINA_SAFETY_ON_FALSE_RETURN(efl_isa(target, MY_CLASS));
 
-   if (pd->mask_src)
+   if (pd->comp_target)
      {
         Efl_Canvas_Vg_Container_Data *pd2 =
-              efl_data_scope_get(pd->mask_src, MY_CLASS);
-        pd2->mask.target = eina_list_remove(pd2->mask.target, obj);
+              efl_data_scope_get(pd->comp_target, MY_CLASS);
+        pd2->comp.src = eina_list_remove(pd2->comp.src, obj);
      }
 
-   if (mask)
+   if (target)
      {
-        Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(mask, MY_CLASS);
-        pd2->mask.target = eina_list_append(pd2->mask.target, obj);
+        Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(target, MY_CLASS);
+        pd2->comp.src = eina_list_append(pd2->comp.src, obj);
      }
 
-   pd->mask.option = op;
-   efl_replace(&pd->mask_src, mask);
+   pd->comp.method = method;
+   efl_replace(&pd->comp_target, target);
    efl_canvas_vg_node_change(obj);
 }
 
@@ -400,12 +384,12 @@ _efl_canvas_vg_container_efl_duplicate_duplicate(const Eo *obj,
    container = efl_duplicate(efl_super(obj, MY_CLASS));
    efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL);
 
-   //Copy Mask
-   if (pd->mask_src)
+   //Copy Composite
+   if (pd->comp_target)
      {
-        Eo * mask_src = efl_duplicate(pd->mask_src);
-        efl_parent_set(mask_src, container);
-        efl_canvas_vg_node_mask_set(container, mask_src, pd->mask.option);
+        Eo * comp_target = efl_duplicate(pd->comp_target);
+        efl_parent_set(comp_target, container);
+        efl_canvas_vg_node_comp_method_set(container, comp_target, pd->comp.method);
      }
 
    //Copy Children
diff --git a/src/lib/evas/canvas/efl_canvas_vg_container.eo b/src/lib/evas/canvas/efl_canvas_vg_container.eo
index a987246531..7b1397d447 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_container.eo
+++ b/src/lib/evas/canvas/efl_canvas_vg_container.eo
@@ -21,6 +21,6 @@ class @beta Efl.Canvas.Vg.Container extends Efl.Canvas.Vg.Node
       Efl.Gfx.Path.bounds_get;
       Efl.Gfx.Path.interpolate;
       Efl.Duplicate.duplicate;
-      Efl.Canvas.Vg.Node.mask { set; }
+      Efl.Canvas.Vg.Node.comp_method { set; }
    }
 }
diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
index 0b1435202b..1d4eb6a154 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
@@ -64,8 +64,8 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA
                                           void *context EINA_UNUSED,
                                           Ector_Surface *surface,
                                           Eina_Matrix3 *ptransform,
-                                          Ector_Buffer *mask,
-                                          int mask_op,
+                                          Ector_Buffer *comp,
+                                          Efl_Gfx_Vg_Composite_Method comp_method,
                                           void *data)
 {
    Efl_Canvas_Vg_Gradient_Linear_Data *pd = data;
@@ -94,7 +94,7 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA
    efl_gfx_gradient_linear_start_set(nd->renderer, pd->start.x, pd->start.y);
    efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y);
    ector_renderer_prepare(nd->renderer);
-   ector_renderer_mask_set(nd->renderer, mask, mask_op);
+   ector_renderer_comp_method_set(nd->renderer, comp, comp_method);
 }
 
 static Eo *
diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
index 691dc5dec8..e54df094ba 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
@@ -80,8 +80,8 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA
                                           void *context EINA_UNUSED,
                                           Ector_Surface *surface,
                                           Eina_Matrix3 *ptransform,
-                                          Ector_Buffer *mask,
-                                          int mask_op,
+                                          Ector_Buffer *comp,
+                                          Efl_Gfx_Vg_Composite_Method comp_method,
                                           void *data)
 {
    Efl_Canvas_Vg_Gradient_Radial_Data *pd = data;
@@ -111,7 +111,7 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA
    efl_gfx_gradient_radial_focal_set(nd->renderer, pd->focal.x, pd->focal.y);
    efl_gfx_gradient_radial_radius_set(nd->renderer, pd->radius);
    ector_renderer_prepare(nd->renderer);
-   ector_renderer_mask_set(nd->renderer, mask, mask_op);
+   ector_renderer_comp_method_set(nd->renderer, comp, comp_method);
 }
 
 static Eo *
diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.c b/src/lib/evas/canvas/efl_canvas_vg_image.c
index d008fd74f9..2b99efbaef 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_image.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_image.c
@@ -21,8 +21,8 @@ _efl_canvas_vg_image_render_pre(Evas_Object_Protected_Data *vg_pd,
                                 void *engine EINA_UNUSED, void *output EINA_UNUSED, void *context EINA_UNUSED,
                                 Ector_Surface *surface,
                                 Eina_Matrix3 *ptransform,
-                                Ector_Buffer *mask,
-                                int mask_op,
+                                Ector_Buffer *comp,
+                                Efl_Gfx_Vg_Composite_Method comp_method,
                                 void *data)
 {
    Efl_Canvas_Vg_Image_Data *pd = data;
@@ -63,7 +63,7 @@ _efl_canvas_vg_image_render_pre(Evas_Object_Protected_Data *vg_pd,
    ector_renderer_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a);
    ector_renderer_visibility_set(nd->renderer, nd->visibility);
 
-   ector_renderer_mask_set(nd->renderer, mask, mask_op);
+   ector_renderer_comp_method_set(nd->renderer, comp, comp_method);
    ector_renderer_prepare(nd->renderer);
 }
 
diff --git a/src/lib/evas/canvas/efl_canvas_vg_node.c b/src/lib/evas/canvas/efl_canvas_vg_node.c
index 95dcdc5152..5064407f03 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_node.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_node.c
@@ -73,10 +73,10 @@ _efl_canvas_vg_node_transformation_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Vg_
 }
 
 static void
-_efl_canvas_vg_node_mask_set(Eo *obj EINA_UNUSED,
-                             Efl_Canvas_Vg_Node_Data *pd EINA_UNUSED,
-                             Efl_Canvas_Vg_Node *mask EINA_UNUSED,
-                             int op EINA_UNUSED)
+_efl_canvas_vg_node_comp_method_set(Eo *obj EINA_UNUSED,
+                                    Efl_Canvas_Vg_Node_Data *pd EINA_UNUSED,
+                                    Efl_Canvas_Vg_Node *target EINA_UNUSED,
+                                    Efl_Gfx_Vg_Composite_Method method EINA_UNUSED)
 {
 }
 
diff --git a/src/lib/evas/canvas/efl_canvas_vg_node.eo b/src/lib/evas/canvas/efl_canvas_vg_node.eo
index e8846fb0c3..a0cbb5d85d 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_node.eo
+++ b/src/lib/evas/canvas/efl_canvas_vg_node.eo
@@ -36,13 +36,13 @@ abstract @beta Efl.Canvas.Vg.Node extends Efl.Object
             y: double; [[$origin y position.]]
          }
       }
-      @property mask {
-         [[Set Mask Node to this renderer]]
+      @property comp_method {
+         [[Set a composite target node to this node object.]]
          set {
          }
          values {
-            mask: Efl.Canvas.Vg.Node; [[Mask object]]
-            op: int; [[Masking Option. Reserved]]
+            target: Efl.Canvas.Vg.Node; [[Composite target node]]
+            method: Efl.Gfx.Vg_Composite_Method; [[Composite Method.]]
          }
       }
    }
diff --git a/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c b/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c
index eda76165cb..559434b294 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c
@@ -24,7 +24,7 @@ evas_vg_node_origin_get(const Efl_Canvas_Vg_Node *obj, double *x, double *y)
 }
 
 EAPI void
-evas_vg_node_mask_set(Efl_Canvas_Vg_Node *obj, Efl_Canvas_Vg_Node *mask, int op)
+evas_vg_node_mask_set(Efl_Canvas_Vg_Node *obj, Efl_Canvas_Vg_Node *mask, int op EINA_UNUSED)
 {
-   efl_canvas_vg_node_mask_set(obj, mask, op);
+   efl_canvas_vg_node_comp_method_set(obj, mask, 0);
 }
diff --git a/src/lib/evas/canvas/efl_canvas_vg_object.c b/src/lib/evas/canvas/efl_canvas_vg_object.c
index a0bcc1ec8f..1617bc1025 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_object.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_object.c
@@ -396,7 +396,7 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
         Eina_List *l;
         Efl_Canvas_Vg_Container_Data *cd = efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS);
 
-        if (cd->mask.target) return;   //Don't draw mask itself.
+        if (cd->comp.src) return;   //Don't draw composite target itself.
 
         int alpha = 255;
         efl_gfx_color_get(node, NULL, NULL, NULL, &alpha);
@@ -508,7 +508,7 @@ _render_to_buffer(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd
    evas_common_draw_context_set_render_op(context, _EVAS_RENDER_COPY);
    evas_common_draw_context_set_color(context, 255, 255, 255, 255);
 
-   //ector begin - end for drawing mask images.
+   //ector begin - end for drawing composite images.
    //ENFN->ector_begin(engine, buffer, context, ector, 0, 0, EINA_FALSE, EINA_FALSE);
    _evas_vg_render_pre(obj, root, engine, buffer, context, ector, NULL, NULL, 0);
    //ENFN->ector_end(engine, buffer, context, ector, EINA_FALSE);
diff --git a/src/lib/evas/canvas/efl_canvas_vg_shape.c b/src/lib/evas/canvas/efl_canvas_vg_shape.c
index fa22b6a3e7..4abdb13af8 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_shape.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_shape.c
@@ -78,8 +78,8 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd,
                                 void *engine, void *output, void *context,
                                 Ector_Surface *surface,
                                 Eina_Matrix3 *ptransform,
-                                Ector_Buffer *mask,
-                                int mask_op,
+                                Ector_Buffer *comp,
+                                Efl_Gfx_Vg_Composite_Method comp_method,
                                 void *data)
 {
    Efl_Canvas_Vg_Shape_Data *pd = data;
@@ -93,13 +93,13 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd,
 
    fill = _evas_vg_render_pre(vg_pd, pd->fill,
                               engine, output, context,
-                              surface, ctransform, mask, mask_op);
+                              surface, ctransform, comp, comp_method);
    stroke_fill = _evas_vg_render_pre(vg_pd, pd->stroke.fill,
                                      engine, output, context,
-                                     surface, ctransform, mask, mask_op);
+                                     surface, ctransform, comp, comp_method);
    stroke_marker = _evas_vg_render_pre(vg_pd, pd->stroke.marker,
                                        engine, output, context,
-                                       surface, ctransform, mask, mask_op);
+                                       surface, ctransform, comp, comp_method);
 
    if (!nd->renderer)
      {
@@ -117,7 +117,7 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd,
    efl_gfx_path_copy_from(nd->renderer, obj);
    efl_gfx_path_commit(nd->renderer);
    ector_renderer_prepare(nd->renderer);
-   ector_renderer_mask_set(nd->renderer, mask, mask_op);
+   ector_renderer_comp_method_set(nd->renderer, comp, comp_method);
 }
 
 static Eo *
diff --git a/src/lib/evas/canvas/evas_vg_private.h b/src/lib/evas/canvas/evas_vg_private.h
index 0fad40d15c..d8a07b24f1 100644
--- a/src/lib/evas/canvas/evas_vg_private.h
+++ b/src/lib/evas/canvas/evas_vg_private.h
@@ -67,7 +67,7 @@ struct _Efl_Canvas_Vg_Node_Data
    void (*render_pre)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node,
          Efl_Canvas_Vg_Node_Data *nd,
          void *engine, void *output, void *contenxt, Ector_Surface *surface,
-         Eina_Matrix3 *ptransform, Ector_Buffer *mask, int mask_op, void *data);
+         Eina_Matrix3 *ptransform, Ector_Buffer *comp, Efl_Gfx_Vg_Composite_Method comp_method, void *data);
    void *data;
 
    double x, y;
@@ -78,24 +78,24 @@ struct _Efl_Canvas_Vg_Node_Data
    Eina_Bool changed : 1;
 };
 
-typedef struct _Vg_Mask
+typedef struct _Vg_Composite
 {
-   Evas_Object_Protected_Data *vg_pd;  //Vector Object (for accessing backend engine)
-   Ector_Buffer *buffer;               //Mask Ector Buffer
-   void *pixels;                       //Mask pixel buffer (actual data)
-   Eina_Rect bound;                    //Mask boundary
-   Eina_List *target;                  //Mask target
-   int option;                         //Mask option
-} Vg_Mask;
+   Evas_Object_Protected_Data *vg_pd;      //Vector Object (for accessing backend engine)
+   Ector_Buffer *buffer;                   //Composite Ector Buffer
+   void *pixels;                           //Composite pixel buffer (actual data)
+   Eina_Rect bound;                        //Composite boundary
+   Eina_List *src;                         //Composite Sources
+   Efl_Gfx_Vg_Composite_Method method;     //Composite Method
+} Vg_Comp;
 
 struct _Efl_Canvas_Vg_Container_Data
 {
    Eina_List *children;
    Eina_Hash *names;
 
-   //Masking feature.
-   Efl_Canvas_Vg_Node *mask_src;         //Mask Source
-   Vg_Mask mask;                         //Mask source data
+   //Composite feature.
+   Efl_Canvas_Vg_Node *comp_target; //Composite target
+   Vg_Comp comp;                    //Composite target data
 
    //Layer transparency feature. This buffer is only valid when the layer has transparency.
    Ector_Buffer *blend_buffer;
@@ -150,13 +150,13 @@ _evas_vg_render_pre(Evas_Object_Protected_Data *vg_pd, Efl_VG *child,
                     void *engine, void *output, void *context,
                     Ector_Surface *surface,
                     Eina_Matrix3 *transform,
-                    Ector_Buffer *mask, int mask_op)
+                    Ector_Buffer *comp, Efl_Gfx_Vg_Composite_Method comp_method)
 {
    if (!child) return NULL;
    Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS);
    if (nd) nd->render_pre(vg_pd, child, nd,
                           engine, output, context, surface,
-                          transform, mask, mask_op, nd->data);
+                          transform, comp, comp_method, nd->data);
    return nd;
 }
 
diff --git a/src/static_libs/vg_common/vg_common_json.c b/src/static_libs/vg_common/vg_common_json.c
index 27fc86e7e6..910a4055e1 100644
--- a/src/static_libs/vg_common/vg_common_json.c
+++ b/src/static_libs/vg_common/vg_common_json.c
@@ -9,21 +9,6 @@
 
 #include <rlottie_capi.h>
 
-//FIXME: This enum add temporarily to help understanding of additional code
-//related to masking in prepare_mask.
-//This needs to be formally declared through the eo class.
-typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE
-{
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT,
-   EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE
-}EFL_CANVAS_VG_NODE_BLEND_TYPE;
-//
-
 static char*
 _get_key_val(void *key)
 {
@@ -311,10 +296,10 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int
         efl_key_data_set(mtarget, key, msource);
      }
 
-   //FIXME : EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA option is temporary
-   //Currently matte alpha implemtnes is same the mask intersect impletment.
+   //FIXME : EFL_GFX_VG_COMPOSITE_METHOD_ALPHA option is temporary
+   //Currently matte alpha implements is same the mask intersect implement.
    //It has been implemented as a multiplication calculation.
-   efl_canvas_vg_node_mask_set(mtarget, msource, EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA);
+   efl_canvas_vg_node_comp_method_set(mtarget, msource, EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA);
 
    mtarget = msource;
 
@@ -332,24 +317,24 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int
           }
         _construct_mask_nodes(msource, mask, depth + 1);
 
-        EFL_CANVAS_VG_NODE_BLEND_TYPE mask_mode;
+        Efl_Gfx_Vg_Composite_Method mask_mode;
         switch (mask->mMode)
           {
            case MaskSubstract:
-              mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT;
+              mask_mode = EFL_GFX_VG_COMPOSITE_METHOD_MASK_SUBSTRACT;
               break;
            case MaskIntersect:
-              mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT;
+              mask_mode = EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT;
               break;
            case MaskDifference:
-              mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE;
+              mask_mode = EFL_GFX_VG_COMPOSITE_METHOD_MASK_DIFFERENCE;
               break;
            case MaskAdd:
            default:
-              mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD;
+              mask_mode = EFL_GFX_VG_COMPOSITE_METHOD_MASK_ADD;
               break;
           }
-        efl_canvas_vg_node_mask_set(mtarget, msource, mask_mode);
+        efl_canvas_vg_node_comp_method_set(mtarget, msource, mask_mode);
         mtarget = msource;
      }
 }
@@ -397,7 +382,7 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de
 
         if (matte_mode != 0)
           {
-             efl_canvas_vg_node_mask_set(ptree, ctree, matte_mode);
+             efl_canvas_vg_node_comp_method_set(ptree, ctree, matte_mode);
              mtarget = ctree;
           }
         matte_mode = (int) clayer->mMatte;
@@ -417,10 +402,10 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de
               matte_mode = 0;
               break;
            case MatteAlpha:
-              matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA;
+              matte_mode = EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA;
               break;
            case MatteAlphaInv:
-              matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV;
+              matte_mode = EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE;
               break;
            case MatteLuma:
               matte_mode = 0;