From aadbdb415311fadf2d161ded9ea4a7c361041ddf Mon Sep 17 00:00:00 2001 From: Hermet Park Date: Tue, 1 Jun 2021 18:38:27 +0900 Subject: [PATCH] Revert "Revert "ector - code clean up."" This reverts commit 2d935a44c1f69a9ac6548efb46900f63c4fd81e7. Change-Id: Ic84ff4a35a9c9827600dc87a5423bcd7aa7764d8 --- src/lib/ector/software/Ector_Software.h | 6 - src/lib/ector/software/ector_renderer_software.eo | 11 - .../ector_renderer_software_gradient_linear.c | 119 --- .../ector_renderer_software_gradient_linear.eo | 15 - .../ector_renderer_software_gradient_radial.c | 129 --- .../ector_renderer_software_gradient_radial.eo | 15 - .../ector/software/ector_renderer_software_image.c | 198 ----- .../software/ector_renderer_software_image.eo | 13 - .../ector/software/ector_renderer_software_shape.c | 831 ------------------ .../software/ector_renderer_software_shape.eo | 15 - src/lib/ector/software/ector_software_gradient.c | 214 ----- src/lib/ector/software/ector_software_gradient.h | 67 -- .../ector/software/ector_software_gradient_sse3.c | 214 ----- src/lib/ector/software/ector_software_rasterizer.c | 946 --------------------- src/lib/ector/software/ector_software_surface.c | 288 ------- src/lib/ector/software/ector_software_surface.eo | 13 - src/lib/ector/software/meson.build | 24 - src/modules/evas/engines/gl_generic/evas_engine.c | 3 - .../evas/engines/software_generic/evas_engine.c | 261 +----- 19 files changed, 17 insertions(+), 3365 deletions(-) delete mode 100644 src/lib/ector/software/ector_renderer_software.eo delete mode 100644 src/lib/ector/software/ector_renderer_software_gradient_linear.c delete mode 100644 src/lib/ector/software/ector_renderer_software_gradient_linear.eo delete mode 100644 src/lib/ector/software/ector_renderer_software_gradient_radial.c delete mode 100644 src/lib/ector/software/ector_renderer_software_gradient_radial.eo delete mode 100644 src/lib/ector/software/ector_renderer_software_image.c delete mode 100644 src/lib/ector/software/ector_renderer_software_image.eo delete mode 100644 src/lib/ector/software/ector_renderer_software_shape.c delete mode 100644 src/lib/ector/software/ector_renderer_software_shape.eo delete mode 100644 src/lib/ector/software/ector_software_gradient.c delete mode 100644 src/lib/ector/software/ector_software_gradient.h delete mode 100644 src/lib/ector/software/ector_software_gradient_sse3.c delete mode 100644 src/lib/ector/software/ector_software_rasterizer.c delete mode 100644 src/lib/ector/software/ector_software_surface.c delete mode 100644 src/lib/ector/software/ector_software_surface.eo diff --git a/src/lib/ector/software/Ector_Software.h b/src/lib/ector/software/Ector_Software.h index 85529e6..4098c1e 100644 --- a/src/lib/ector/software/Ector_Software.h +++ b/src/lib/ector/software/Ector_Software.h @@ -31,14 +31,8 @@ #ifdef EFL_BETA_API_SUPPORT -#include "software/ector_software_surface.eo.h" #include "software/ector_software_buffer.eo.h" #include "software/ector_software_buffer_base.eo.h" -#include "software/ector_renderer_software.eo.h" -#include "software/ector_renderer_software_shape.eo.h" -#include "software/ector_renderer_software_image.eo.h" -#include "software/ector_renderer_software_gradient_linear.eo.h" -#include "software/ector_renderer_software_gradient_radial.eo.h" #endif diff --git a/src/lib/ector/software/ector_renderer_software.eo b/src/lib/ector/software/ector_renderer_software.eo deleted file mode 100644 index 00e1040..0000000 --- a/src/lib/ector/software/ector_renderer_software.eo +++ /dev/null @@ -1,11 +0,0 @@ -abstract @beta Ector.Renderer.Software extends Ector.Renderer -{ - [[Ector software renderer class]] - data: null; - methods { - op_fill @pure_virtual { - [[Renderer fill operation]] - return: bool; [[$true on success, $false otherwise]] - } - } -} diff --git a/src/lib/ector/software/ector_renderer_software_gradient_linear.c b/src/lib/ector/software/ector_renderer_software_gradient_linear.c deleted file mode 100644 index 0e5bc93..0000000 --- a/src/lib/ector/software/ector_renderer_software_gradient_linear.c +++ /dev/null @@ -1,119 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" -#include "ector_software_gradient.h" - -static Eina_Bool -_ector_renderer_software_gradient_linear_ector_renderer_prepare(Eo *obj, - Ector_Renderer_Software_Gradient_Data *pd) -{ - pd->ctable_status = CTABLE_NOT_READY; - - if (!pd->surface) - { - Ector_Renderer_Data *base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS); - pd->surface = efl_data_xref(base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj); - } - ector_software_gradient_color_update(pd); - - pd->linear.x1 = pd->gld->start.x; - pd->linear.y1 = pd->gld->start.y; - - pd->linear.x2 = pd->gld->end.x; - pd->linear.y2 = pd->gld->end.y; - - pd->linear.dx = pd->linear.x2 - pd->linear.x1; - pd->linear.dy = pd->linear.y2 - pd->linear.y1; - pd->linear.l = pd->linear.dx * pd->linear.dx + pd->linear.dy * pd->linear.dy; - pd->linear.off = 0; - - if (!EINA_DBL_EQ(pd->linear.l, 0.0)) - { - pd->linear.dx /= pd->linear.l; - pd->linear.dy /= pd->linear.l; - pd->linear.off = -pd->linear.dx * pd->linear.x1 - pd->linear.dy * pd->linear.y1; - } - - return EINA_FALSE; -} - -static Eina_Bool -_ector_renderer_software_gradient_linear_ector_renderer_draw(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED, - Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED, - unsigned int mul_col EINA_UNUSED) -{ - return EINA_TRUE; -} - -static Eina_Bool -_ector_renderer_software_gradient_linear_ector_renderer_software_op_fill(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Gradient_Data *pd) -{ - ector_software_rasterizer_linear_gradient_set(pd->surface->rasterizer, pd); - ector_software_gradient_color_update(pd); - - return EINA_TRUE; -} - -static Eo * -_ector_renderer_software_gradient_linear_efl_object_constructor(Eo *obj, - Ector_Renderer_Software_Gradient_Data *pd) -{ - obj = efl_constructor(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS)); - if (!obj) return NULL; - - pd->gd = efl_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj); - pd->gld = efl_data_xref(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN, obj); - pd->ctable_status = CTABLE_NOT_READY; - - return obj; -} - -static void -_ector_renderer_software_gradient_linear_efl_object_destructor(Eo *obj, - Ector_Renderer_Software_Gradient_Data *pd) -{ - Ector_Renderer_Data *base; - - destroy_color_table(pd); - - base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS); - efl_data_xunref(base->surface, pd->surface, obj); - - efl_data_xunref(obj, pd->gd, obj); - efl_data_xunref(obj, pd->gld, obj); - - efl_destructor(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS)); -} - -void -_ector_renderer_software_gradient_linear_efl_gfx_gradient_stop_set(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED, - const Efl_Gfx_Gradient_Stop *colors, unsigned int length) -{ - efl_gfx_gradient_stop_set(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS), colors, length); -} - -static unsigned int -_ector_renderer_software_gradient_linear_ector_renderer_crc_get(const Eo *obj, Ector_Renderer_Software_Gradient_Data *pd) -{ - unsigned int crc; - - crc = ector_renderer_crc_get(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS)); - - crc = eina_crc((void*) pd->gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE); - if (pd->gd->colors_count) - crc = eina_crc((void*) pd->gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gd->colors_count, crc, EINA_FALSE); - crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Gradient_Linear_Data), crc, EINA_FALSE); - - return crc; -} - -#include "ector_renderer_software_gradient_linear.eo.c" diff --git a/src/lib/ector/software/ector_renderer_software_gradient_linear.eo b/src/lib/ector/software/ector_renderer_software_gradient_linear.eo deleted file mode 100644 index 5f4f539..0000000 --- a/src/lib/ector/software/ector_renderer_software_gradient_linear.eo +++ /dev/null @@ -1,15 +0,0 @@ -class @beta Ector.Renderer.Software.Gradient.Linear extends Ector.Renderer.Software implements Ector.Renderer.Gradient, Ector.Renderer.Gradient.Linear -{ - [[Ector software renderer gradient linear class]] - c_prefix: ector_renderer_software_gradient_linear; - data: Ector_Renderer_Software_Gradient_Data; - implements { - Ector.Renderer.prepare; - Ector.Renderer.draw; - Ector.Renderer.crc { get; } - Ector.Renderer.Software.op_fill; - Efl.Object.constructor; - Efl.Object.destructor; - Efl.Gfx.Gradient.stop { set; } - } -} diff --git a/src/lib/ector/software/ector_renderer_software_gradient_radial.c b/src/lib/ector/software/ector_renderer_software_gradient_radial.c deleted file mode 100644 index 6f6c877..0000000 --- a/src/lib/ector/software/ector_renderer_software_gradient_radial.c +++ /dev/null @@ -1,129 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" -#include "ector_software_gradient.h" - -static Eina_Bool -_ector_renderer_software_gradient_radial_ector_renderer_prepare(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd) -{ - pd->ctable_status = CTABLE_NOT_READY; - - if (!pd->surface) - { - Ector_Renderer_Data *base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS); - pd->surface = efl_data_xref(base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj); - } - - ector_software_gradient_color_update(pd); - - pd->radial.cx = pd->grd->radial.x; - pd->radial.cy = pd->grd->radial.y; - pd->radial.cradius = pd->grd->radius; - - if (EINA_DBL_EQ(pd->grd->focal.x, 0.0)) - pd->radial.fx = pd->grd->radial.x; - else - pd->radial.fx = pd->grd->focal.x; - - if (EINA_DBL_EQ(pd->grd->focal.y, 0.0)) - pd->radial.fy = pd->grd->radial.y; - else - pd->radial.fy = pd->grd->focal.y; - - pd->radial.fradius = 0; - - pd->radial.dx = pd->radial.cx - pd->radial.fx; - pd->radial.dy = pd->radial.cy - pd->radial.fy; - - pd->radial.dr = pd->radial.cradius - pd->radial.fradius; - pd->radial.sqrfr = pd->radial.fradius * pd->radial.fradius; - - pd->radial.a = pd->radial.dr * pd->radial.dr - - pd->radial.dx * pd->radial.dx - - pd->radial.dy * pd->radial.dy; - pd->radial.inv2a = 1 / (2 * pd->radial.a); - - pd->radial.extended = (pd->radial.fradius >= 0.00001f) || pd->radial.a >= 0.00001f; - - return EINA_FALSE; -} - -// Clearly duplicated and should be in a common place... -static Eina_Bool -_ector_renderer_software_gradient_radial_ector_renderer_draw(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED, - Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED, - unsigned int mul_col EINA_UNUSED) -{ - return EINA_TRUE; -} - -// Clearly duplicated and should be in a common place... -static Eina_Bool -_ector_renderer_software_gradient_radial_ector_renderer_software_op_fill(Eo *obj EINA_UNUSED, Ector_Renderer_Software_Gradient_Data *pd) -{ - ector_software_rasterizer_radial_gradient_set(pd->surface->rasterizer, pd); - ector_software_gradient_color_update(pd); - - return EINA_TRUE; -} - -Eo * -_ector_renderer_software_gradient_radial_efl_object_constructor(Eo *obj, - Ector_Renderer_Software_Gradient_Data *pd) -{ - obj = efl_constructor(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS)); - pd->gd = efl_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj); - pd->gld = efl_data_xref(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN, obj); - pd->ctable_status = CTABLE_NOT_READY; - - return obj; -} - -void -_ector_renderer_software_gradient_radial_efl_object_destructor(Eo *obj, - Ector_Renderer_Software_Gradient_Data *pd) -{ - Ector_Renderer_Data *base; - - destroy_color_table(pd); - - base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS); - efl_data_xunref(base->surface, pd->surface, obj); - - efl_data_xunref(obj, pd->gd, obj); - efl_data_xunref(obj, pd->gld, obj); - - efl_destructor(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS)); -} - -void -_ector_renderer_software_gradient_radial_efl_gfx_gradient_stop_set(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED, - const Efl_Gfx_Gradient_Stop *colors, unsigned int length) -{ - efl_gfx_gradient_stop_set(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS), colors, length); -} - -static unsigned int -_ector_renderer_software_gradient_radial_ector_renderer_crc_get(const Eo *obj, Ector_Renderer_Software_Gradient_Data *pd) -{ - unsigned int crc; - - crc = ector_renderer_crc_get(efl_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS)); - - crc = eina_crc((void*) pd->gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE); - if (pd->gd->colors_count) - crc = eina_crc((void*) pd->gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gd->colors_count, crc, EINA_FALSE); - crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Gradient_Radial_Data), crc, EINA_FALSE); - - return crc; -} - -#include "ector_renderer_software_gradient_radial.eo.c" diff --git a/src/lib/ector/software/ector_renderer_software_gradient_radial.eo b/src/lib/ector/software/ector_renderer_software_gradient_radial.eo deleted file mode 100644 index b0a36d3..0000000 --- a/src/lib/ector/software/ector_renderer_software_gradient_radial.eo +++ /dev/null @@ -1,15 +0,0 @@ -class @beta Ector.Renderer.Software.Gradient.Radial extends Ector.Renderer.Software implements Ector.Renderer.Gradient, Ector.Renderer.Gradient.Radial -{ - [[Ector software renderer gradient radial]] - c_prefix: ector_renderer_software_gradient_radial; - data: Ector_Renderer_Software_Gradient_Data; - implements { - Ector.Renderer.prepare; - Ector.Renderer.draw; - Ector.Renderer.crc { get; } - Ector.Renderer.Software.op_fill; - Efl.Object.constructor; - Efl.Object.destructor; - Efl.Gfx.Gradient.stop { set; } - } -} diff --git a/src/lib/ector/software/ector_renderer_software_image.c b/src/lib/ector/software/ector_renderer_software_image.c deleted file mode 100644 index d7807ed..0000000 --- a/src/lib/ector/software/ector_renderer_software_image.c +++ /dev/null @@ -1,198 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include - -#include -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" - -#define MY_CLASS ECTOR_RENDERER_SOFTWARE_IMAGE_CLASS - -typedef struct _Ector_Renderer_Software_Image_Data Ector_Renderer_Software_Image_Data; - -struct _Ector_Renderer_Software_Image_Data -{ - Ector_Software_Surface_Data *surface; - Ector_Renderer_Image_Data *image; - Ector_Renderer_Data *base; - Ector_Buffer *comp; - Efl_Gfx_Vg_Composite_Method comp_method; - int opacity; - Eina_Matrix3 inv_m; - struct { - int x1, y1, x2, y2; - } boundary; -}; - -static Eina_Bool -_ector_renderer_software_image_ector_renderer_prepare(Eo *obj, - Ector_Renderer_Software_Image_Data *pd) -{ - if (!pd->surface) - pd->surface = efl_data_xref(pd->base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj); - - if (!pd->image->buffer || !pd->surface->rasterizer->fill_data.raster_buffer) - return EINA_FALSE; - - Eina_Matrix3 m; - double m11, m12, m21, m22, m31, m32; - int x = pd->surface->x + (int)pd->base->origin.x; - int y = pd->surface->y + (int)pd->base->origin.y; - int image_w, image_h; - ector_buffer_size_get(pd->image->buffer, &image_w, &image_h); - - double px[4] = {x, x + image_w, x, x + image_w}; - double py[4] = {y, y, y + image_h, y + image_h}; - - //Only use alpha color - pd->opacity = pd->base->color.a; - /*ector_software_rasterizer_color_set(pd->surface->rasterizer, - pd->base->color.r, - pd->base->color.g, - pd->base->color.b, - pd->base->color.a);*/ - - if (!pd->base->m) - { - eina_matrix3_identity(&m); - eina_matrix3_scale(&m, (double)pd->surface->rasterizer->fill_data.raster_buffer->generic->w / (double)image_w, - (double)pd->surface->rasterizer->fill_data.raster_buffer->generic->h / (double)image_h); - } - else - eina_matrix3_copy(&m, pd->base->m); - eina_matrix3_values_get(&m, &m11, &m12, NULL, - &m21, &m22, NULL, - &m31, &m32, NULL); - //Calc draw boundbox - pd->boundary.x1 = MAX(pd->surface->rasterizer->fill_data.raster_buffer->generic->w , (unsigned int)image_w); - pd->boundary.y1 = MAX(pd->surface->rasterizer->fill_data.raster_buffer->generic->h , (unsigned int)image_h); - pd->boundary.x2 = 0; pd->boundary.y2 = 0; - for (int i = 0; i < 4; i++) - { - pd->boundary.x1 = MIN(pd->boundary.x1, (int)(((px[i] * m11) + (py[i] * m21) + m31) + 0.5)); - pd->boundary.y1 = MIN(pd->boundary.y1, (int)(((px[i] * m12) + (py[i] * m22) + m32) + 0.5)); - - pd->boundary.x2 = MAX(pd->boundary.x2, (int)(((px[i] * m11) + (py[i] * m21) + m31) + 0.5)); - pd->boundary.y2 = MAX(pd->boundary.y2, (int)(((px[i] * m12) + (py[i] * m22) + m32) + 0.5)); - } - - eina_matrix3_inverse(&m, &pd->inv_m); - - return EINA_TRUE; -} - -//FIXME: We need to implement that apply op, clips and mul_col. -static Eina_Bool -_ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Image_Data *pd, - Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED, - unsigned int mul_col EINA_UNUSED) -{ - if (!pd->image->buffer || !pd->surface->rasterizer->fill_data.raster_buffer->pixels.u32) - return EINA_FALSE; - - if (pd->opacity == 0) - return EINA_TRUE; - - const int pix_stride = pd->surface->rasterizer->fill_data.raster_buffer->stride / 4; - 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; - int image_w, image_h; - - int dst_buf_width = MIN(pd->boundary.x2, (int)pd->surface->rasterizer->fill_data.raster_buffer->generic->w); - int dst_buf_height = MIN(pd->boundary.y2, (int)pd->surface->rasterizer->fill_data.raster_buffer->generic->h); - - ector_buffer_size_get(pd->image->buffer, &image_w, &image_h); - - dst_buf = pd->surface->rasterizer->fill_data.raster_buffer->pixels.u32; - src_buf = bpd->pixels.u32; - - eina_matrix3_values_get(&pd->inv_m, &im11, &im12, NULL, - &im21, &im22, NULL, - &im31, &im32, NULL); - - //Draw - for (int local_y = pd->boundary.y1; local_y < dst_buf_height; local_y++) - { - for (int local_x = pd->boundary.x1; local_x < dst_buf_width; local_x++) - { - uint32_t *dst = dst_buf + ((int)local_x + ((int)local_y * pix_stride)); - int rx, ry; - rx = (int)(((double)local_x * im11) + ((double)local_y * im21) + im31 + 0.5); - ry = (int)(((double)local_x * im12) + ((double)local_y * im22) + im32 + 0.5); - if (rx < 0 || rx >= image_w || ry < 0 || ry >= image_h) - continue; - uint32_t *src = src_buf + (rx + (ry * image_w)); //FIXME: use to stride - uint32_t temp = 0x0; - if (comp) - { - 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); - } - else - { - temp = draw_mul_256(pd->opacity, *src); - } - int inv_alpha = 255 - ((temp) >> 24); - *dst = temp + draw_mul_256(inv_alpha, *dst); - } - } - - return EINA_TRUE; -} - -static Eo * -_ector_renderer_software_image_efl_object_constructor(Eo *obj, Ector_Renderer_Software_Image_Data *pd) -{ - obj = efl_constructor(efl_super(obj, MY_CLASS)); - if (!obj) return NULL; - - pd->image = efl_data_xref(obj, ECTOR_RENDERER_IMAGE_MIXIN, obj); - pd->base = efl_data_xref(obj, ECTOR_RENDERER_CLASS, obj); - - return obj; -} - -static void -_ector_renderer_software_image_efl_object_destructor(Eo *obj, Ector_Renderer_Software_Image_Data *pd) -{ - efl_data_xunref(pd->base->surface, pd->surface, obj); - efl_data_xunref(obj, pd->base, obj); - efl_data_xunref(obj, pd->image, obj); - - efl_destructor(efl_super(obj, MY_CLASS)); -} - -unsigned int -_ector_renderer_software_image_ector_renderer_crc_get(const Eo *obj, - Ector_Renderer_Software_Image_Data *pd) -{ - unsigned int crc; - - crc = ector_renderer_crc_get(efl_super(obj, MY_CLASS)); - - crc = eina_crc((void*) pd->image, sizeof (Ector_Renderer_Image_Data), crc, EINA_FALSE); - return crc; -} - -static void -_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->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 deleted file mode 100644 index 4771702..0000000 --- a/src/lib/ector/software/ector_renderer_software_image.eo +++ /dev/null @@ -1,13 +0,0 @@ -class @beta Ector.Renderer.Software.Image extends Ector.Renderer.Software implements Ector.Renderer.Image -{ - [[Ector software renderer image class]] - c_prefix: ector_renderer_software_image; - implements { - Ector.Renderer.prepare; - Ector.Renderer.draw; - 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 deleted file mode 100644 index 658a82e..0000000 --- a/src/lib/ector/software/ector_renderer_software_shape.c +++ /dev/null @@ -1,831 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include - -#include -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" - -#define MY_CLASS ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS - -typedef struct _Ector_Renderer_Software_Shape_Data Ector_Renderer_Software_Shape_Data; -typedef struct _Ector_Software_Shape_Task Ector_Software_Shape_Task; - -struct _Ector_Software_Shape_Task -{ - Ector_Renderer_Software_Shape_Data *pd; - - const Efl_Gfx_Path_Command *cmds; - const double *pts; - - Efl_Gfx_Fill_Rule fill_rule; -}; - -struct _Ector_Renderer_Software_Shape_Data -{ - Efl_Gfx_Shape_Public *public_shape; - - Ector_Software_Surface_Data *surface; - Ector_Renderer_Shape_Data *shape; - Ector_Renderer_Data *base; - - Shape_Rle_Data *shape_data; - Shape_Rle_Data *outline_data; - - Ector_Buffer *comp; - Efl_Gfx_Vg_Composite_Method comp_method; - - Ector_Software_Shape_Task *task; -}; - -typedef struct _Outline -{ - SW_FT_Outline ft_outline; - int points_alloc; - int contours_alloc; -} Outline; - - -#define TO_FT_COORD(x) ((x) * 64) // to freetype 26.6 coordinate. - -static inline void -_grow_outline_contour(Outline *outline, int num) -{ - if ( outline->ft_outline.n_contours + num > outline->contours_alloc) - { - outline->contours_alloc += 5; - outline->ft_outline.contours = (short *) realloc(outline->ft_outline.contours, - outline->contours_alloc * sizeof(short)); - } -} - -static inline void -_grow_outline_points(Outline *outline, int num) -{ - if ( outline->ft_outline.n_points + num > outline->points_alloc) - { - outline->points_alloc += 50; - outline->ft_outline.points = (SW_FT_Vector *) realloc(outline->ft_outline.points, - outline->points_alloc * sizeof(SW_FT_Vector)); - outline->ft_outline.tags = (char *) realloc(outline->ft_outline.tags, - outline->points_alloc * sizeof(char)); - } -} -static Outline * -_outline_create() -{ - Outline *outline = (Outline *) calloc(1, sizeof(Outline)); - outline->points_alloc = 0; - outline->contours_alloc = 0; - _grow_outline_contour(outline, 1); - _grow_outline_points(outline, 1); - return outline; -} - -static -void _outline_destroy(Outline *outline) -{ - if (outline) - { - free(outline->ft_outline.points); - free(outline->ft_outline.tags); - free(outline->ft_outline.contours); - free(outline); - } -} - -static void -_outline_move_to(Outline *outline, double x, double y) -{ - SW_FT_Outline *ft_outline = &outline->ft_outline; - - _grow_outline_points(outline, 1); - ft_outline->points[ft_outline->n_points].x = TO_FT_COORD(x); - ft_outline->points[ft_outline->n_points].y = TO_FT_COORD(y); - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_ON; - - if (ft_outline->n_points) - { - _grow_outline_contour(outline, 1); - ft_outline->contours[ft_outline->n_contours] = ft_outline->n_points - 1; - ft_outline->n_contours++; - } - - ft_outline->n_points++; -} - -static void -_outline_end(Outline *outline) -{ - SW_FT_Outline *ft_outline = &outline->ft_outline; - - _grow_outline_contour(outline, 1); - - if (ft_outline->n_points) - { - ft_outline->contours[ft_outline->n_contours] = ft_outline->n_points - 1; - ft_outline->n_contours++; - } -} - - -static void _outline_line_to(Outline *outline, double x, double y) -{ - SW_FT_Outline *ft_outline = &outline->ft_outline; - - _grow_outline_points(outline, 1); - ft_outline->points[ft_outline->n_points].x = TO_FT_COORD(x); - ft_outline->points[ft_outline->n_points].y = TO_FT_COORD(y); - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_ON; - ft_outline->n_points++; -} - - -static Eina_Bool -_outline_close_path(Outline *outline) -{ - SW_FT_Outline *ft_outline = &outline->ft_outline; - int index ; - - if (ft_outline->n_contours) - { - index = ft_outline->contours[ft_outline->n_contours - 1] + 1; - } - else - { - // First path - index = 0; - } - - // Make sure there is at least one point in the current path - if (ft_outline->n_points == index) return EINA_FALSE; - - // Close the path - _grow_outline_points(outline, 1); - ft_outline->points[ft_outline->n_points].x = ft_outline->points[index].x; - ft_outline->points[ft_outline->n_points].y = ft_outline->points[index].y; - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_ON; - ft_outline->n_points++; - - return EINA_TRUE; -} - - -static void _outline_cubic_to(Outline *outline, double cx1, double cy1, - double cx2, double cy2, double x, double y) -{ - SW_FT_Outline *ft_outline = &outline->ft_outline; - - _grow_outline_points(outline, 3); - - ft_outline->points[ft_outline->n_points].x = TO_FT_COORD(cx1); - ft_outline->points[ft_outline->n_points].y = TO_FT_COORD(cy1); - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_CUBIC; - ft_outline->n_points++; - - ft_outline->points[ft_outline->n_points].x = TO_FT_COORD(cx2); - ft_outline->points[ft_outline->n_points].y = TO_FT_COORD(cy2); - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_CUBIC; - ft_outline->n_points++; - - ft_outline->points[ft_outline->n_points].x = TO_FT_COORD(x); - ft_outline->points[ft_outline->n_points].y = TO_FT_COORD(y); - ft_outline->tags[ft_outline->n_points] = SW_FT_CURVE_TAG_ON; - ft_outline->n_points++; -} - -static void _outline_transform(Outline *outline, Eina_Matrix3 *m) -{ - int i; - double x, y; - SW_FT_Outline *ft_outline = &outline->ft_outline; - - if (m && (eina_matrix3_type_get(m) != EINA_MATRIX_TYPE_IDENTITY)) - { - for (i = 0; i < ft_outline->n_points; i++) - { - eina_matrix3_point_transform(m, - ft_outline->points[i].x/64.0,/* convert back to normal coord.*/ - ft_outline->points[i].y/64.0,/* convert back to normal coord.*/ - &x, &y); - - ft_outline->points[i].x = TO_FT_COORD(x); - ft_outline->points[i].y = TO_FT_COORD(y); - } - } -} - -static Eina_Bool -_generate_outline(const Efl_Gfx_Path_Command *cmds, const double *pts, Outline * outline) -{ - Eina_Bool close_path = EINA_FALSE; - for (; *cmds != EFL_GFX_PATH_COMMAND_TYPE_END; cmds++) - { - switch (*cmds) - { - case EFL_GFX_PATH_COMMAND_TYPE_MOVE_TO: - - _outline_move_to(outline, pts[0], pts[1]); - - pts += 2; - break; - case EFL_GFX_PATH_COMMAND_TYPE_LINE_TO: - - _outline_line_to(outline, pts[0], pts[1]); - - pts += 2; - break; - case EFL_GFX_PATH_COMMAND_TYPE_CUBIC_TO: - - _outline_cubic_to(outline, - pts[0], pts[1], pts[2], pts[3], // control points - pts[4], pts[5]); // destination point - pts += 6; - break; - - case EFL_GFX_PATH_COMMAND_TYPE_CLOSE: - - close_path = _outline_close_path(outline); - break; - - case EFL_GFX_PATH_COMMAND_TYPE_LAST: - case EFL_GFX_PATH_COMMAND_TYPE_END: - break; - } - } - _outline_end(outline); - return close_path; -} - -typedef struct _Line -{ - double x1; - double y1; - double x2; - double y2; -}Line; - -static void -_line_value_set(Line *l, double x1, double y1, double x2, double y2) -{ - l->x1 = x1; - l->y1 = y1; - l->x2 = x2; - l->y2 = y2; -} - -// approximate sqrt(x*x + y*y) using alpha max plus beta min algorithm. -// With alpha = 1, beta = 3/8, giving results with the largest error less -// than 7% compared to the exact value. -static double -_line_length(Line *l) -{ - double x = l->x2 - l->x1; - double y = l->y2 - l->y1; - x = x < 0 ? -x : x; - y = y < 0 ? -y : y; - return (x > y ? x + 0.375 * y : y + 0.375 * x); -} - -static void -_line_split_at_length(Line *l, double length, Line *left, Line *right) -{ - double len = _line_length(l); - double dx = ((l->x2 - l->x1)/len) *length; - double dy = ((l->y2 - l->y1)/len) *length; - - left->x1 = l->x1; - left->y1 = l->y1; - left->x2 = left->x1 + dx; - left->y2 = left->y1 + dy; - - right->x1 = left->x2; - right->y1 = left->y2; - right->x2 = l->x2; - right->y2 = l->y2; -} - -typedef struct _Dash_Stroker -{ - Efl_Gfx_Dash *dash; - int dash_len; - Outline *outline; - int cur_dash_index; - double cur_dash_length; - Eina_Bool cur_op_gap; - double start_x, start_y; - double cur_x, cur_y; -}Dash_Stroker; - -static void -_dasher_line_to(Dash_Stroker *dasher, double x, double y) -{ - Line l, left, right; - double line_len = 0.0; - _line_value_set(&l, dasher->cur_x, dasher->cur_y, x, y); - line_len = _line_length(&l); - if (line_len < dasher->cur_dash_length) - { - dasher->cur_dash_length -= line_len; - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, dasher->cur_x, dasher->cur_y); - _outline_line_to(dasher->outline, x, y); - } - } - else - { - while (line_len > dasher->cur_dash_length) - { - line_len -= dasher->cur_dash_length; - _line_split_at_length(&l, dasher->cur_dash_length, &left, &right); - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, left.x1, left.y1); - _outline_line_to(dasher->outline, left.x2, left.y2); - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].gap; - } - else - { - dasher->cur_dash_index = (dasher->cur_dash_index +1) % dasher->dash_len ; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].length; - } - dasher->cur_op_gap = !dasher->cur_op_gap; - l = right; - dasher->cur_x = l.x1; - dasher->cur_y = l.y1; - } - // remainder - dasher->cur_dash_length -= line_len; - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, l.x1, l.y1); - _outline_line_to(dasher->outline, l.x2, l.y2); - } - if (dasher->cur_dash_length < 1.0) - { - // move to next dash - if (!dasher->cur_op_gap) - { - dasher->cur_op_gap = EINA_TRUE; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].gap; - } - else - { - dasher->cur_op_gap = EINA_FALSE; - dasher->cur_dash_index = (dasher->cur_dash_index +1) % dasher->dash_len ; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].length; - } - } - } - dasher->cur_x = x; - dasher->cur_y = y; -} - -static void -_dasher_cubic_to(Dash_Stroker *dasher, double cx1 , double cy1, double cx2, double cy2, double x, double y) -{ - Eina_Bezier b, left, right; - double bez_len = 0.0; - eina_bezier_values_set(&b, dasher->cur_x, dasher->cur_y, cx1, cy1, cx2, cy2, x, y); - bez_len = eina_bezier_length_get(&b); - if (bez_len < dasher->cur_dash_length) - { - dasher->cur_dash_length -= bez_len; - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, dasher->cur_x, dasher->cur_y); - _outline_cubic_to(dasher->outline, cx1, cy1, cx2, cy2, x, y); - } - } - else - { - while (bez_len > dasher->cur_dash_length) - { - bez_len -= dasher->cur_dash_length; - eina_bezier_split_at_length(&b, dasher->cur_dash_length, &left, &right); - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, left.start.x, left.start.y); - _outline_cubic_to(dasher->outline, left.ctrl_start.x, left.ctrl_start.y, left.ctrl_end.x, left.ctrl_end.y, left.end.x, left.end.y); - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].gap; - } - else - { - dasher->cur_dash_index = (dasher->cur_dash_index +1) % dasher->dash_len ; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].length; - } - dasher->cur_op_gap = !dasher->cur_op_gap; - b = right; - dasher->cur_x = b.start.x; - dasher->cur_y = b.start.y; - } - // remainder - dasher->cur_dash_length -= bez_len; - if (!dasher->cur_op_gap) - { - _outline_move_to(dasher->outline, b.start.x, b.start.y); - _outline_cubic_to(dasher->outline, b.ctrl_start.x, b.ctrl_start.y, b.ctrl_end.x, b.ctrl_end.y, b.end.x, b.end.y); - } - if (dasher->cur_dash_length < 1.0) - { - // move to next dash - if (!dasher->cur_op_gap) - { - dasher->cur_op_gap = EINA_TRUE; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].gap; - } - else - { - dasher->cur_op_gap = EINA_FALSE; - dasher->cur_dash_index = (dasher->cur_dash_index +1) % dasher->dash_len ; - dasher->cur_dash_length = dasher->dash[dasher->cur_dash_index].length; - } - } - } - dasher->cur_x = x; - dasher->cur_y = y; -} - -static Eina_Bool -_generate_dashed_outline(const Efl_Gfx_Path_Command *cmds, const double *pts, Outline * outline, Efl_Gfx_Dash *dash, int dash_len) -{ - Dash_Stroker dasher; - dasher.dash = dash; - dasher.dash_len = dash_len; - dasher.outline = outline; - dasher.cur_dash_length = 0.0; - dasher.cur_dash_index = 0; - dasher.cur_op_gap = EINA_FALSE; - dasher.start_x = 0.0; - dasher.start_y = 0.0; - dasher.cur_x = 0.0; - dasher.cur_y = 0.0; - - for (; *cmds != EFL_GFX_PATH_COMMAND_TYPE_END; cmds++) - { - switch (*cmds) - { - case EFL_GFX_PATH_COMMAND_TYPE_MOVE_TO: - { - // reset the dash - dasher.cur_dash_index = 0; - dasher.cur_dash_length = dasher.dash[0].length; - dasher.cur_op_gap = EINA_FALSE; - dasher.start_x = pts[0]; - dasher.start_y = pts[1]; - dasher.cur_x = pts[0]; - dasher.cur_y = pts[1]; - pts += 2; - } - break; - case EFL_GFX_PATH_COMMAND_TYPE_LINE_TO: - _dasher_line_to(&dasher, pts[0], pts[1]); - pts += 2; - break; - case EFL_GFX_PATH_COMMAND_TYPE_CUBIC_TO: - _dasher_cubic_to(&dasher, pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]); - pts += 6; - break; - - case EFL_GFX_PATH_COMMAND_TYPE_CLOSE: - _dasher_line_to(&dasher, dasher.start_x, dasher.start_y); - break; - - case EFL_GFX_PATH_COMMAND_TYPE_LAST: - case EFL_GFX_PATH_COMMAND_TYPE_END: - break; - } - } - _outline_end(outline); - return EINA_FALSE; -} - -static Eina_Bool -_generate_stroke_data(Ector_Renderer_Software_Shape_Data *pd) -{ - if (pd->outline_data) return EINA_FALSE; - - if (!pd->shape->stroke.fill && - ((pd->public_shape->stroke.color.a == 0) || - (pd->public_shape->stroke.width < 0.01))) - return EINA_FALSE; - - return EINA_TRUE; -} - -static Eina_Bool -_generate_shape_data(Ector_Renderer_Software_Shape_Data *pd) -{ - if (pd->shape_data) return EINA_FALSE; - - if (!pd->shape->fill && (pd->base->color.a == 0)) return EINA_FALSE; - - return EINA_TRUE; -} - -static Ector_Software_Shape_Task * -_need_update_rle(Eo *obj, Ector_Renderer_Software_Shape_Data *pd) -{ - if (pd->task) return pd->task; - - if (!pd->base->visibility || (!_generate_stroke_data(pd) && - !_generate_shape_data(pd))) - return NULL; - - const Efl_Gfx_Path_Command *cmds; - const double *pts; - efl_gfx_path_get(obj, &cmds, &pts); - if (!cmds) return NULL; - - Ector_Software_Shape_Task *task = malloc(sizeof(Ector_Software_Shape_Task)); - if (!task) return NULL; - - task->pd = pd; - task->cmds = cmds; - task->pts = pts; - task->fill_rule = efl_gfx_shape_fill_rule_get(obj); - - pd->task = task; - - return task; -} - -static void -_done_rle(void *data) -{ - Ector_Software_Shape_Task *task = data; - if (!task) return; - if (task->pd) task->pd->task = NULL; - free(task); -} - -static void -_update_rle(void *data, Ector_Software_Thread *thread) -{ - Ector_Software_Shape_Task *task = data; - Eina_Bool close_path; - Outline *outline, *dash_outline; - - outline = _outline_create(); - close_path = _generate_outline(task->cmds, task->pts, outline); - if (task->fill_rule == EFL_GFX_FILL_RULE_ODD_EVEN) - outline->ft_outline.flags = SW_FT_OUTLINE_EVEN_ODD_FILL; - else - outline->ft_outline.flags = SW_FT_OUTLINE_NONE; // default is winding fill - - _outline_transform(outline, task->pd->base->m); - - //shape data generation - if (_generate_shape_data(task->pd)) - task->pd->shape_data = ector_software_rasterizer_generate_rle_data(thread, - task->pd->surface->rasterizer, - &outline->ft_outline); - - //stroke data generation - if (_generate_stroke_data(task->pd)) - { - ector_software_rasterizer_stroke_set(thread, task->pd->surface->rasterizer, - (task->pd->public_shape->stroke.width * - task->pd->public_shape->stroke.scale), - task->pd->public_shape->stroke.cap, - task->pd->public_shape->stroke.join, - task->pd->base->m, - task->pd->public_shape->stroke.miterlimit); - - if (task->pd->public_shape->stroke.dash) - { - dash_outline = _outline_create(); - close_path = _generate_dashed_outline(task->cmds, task->pts, dash_outline, - task->pd->public_shape->stroke.dash, - task->pd->public_shape->stroke.dash_length); - _outline_transform(dash_outline, task->pd->base->m); - task->pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(thread, - task->pd->surface->rasterizer, - &dash_outline->ft_outline, - close_path); - _outline_destroy(dash_outline); - } - else - { - task->pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(thread, - task->pd->surface->rasterizer, - &outline->ft_outline, - close_path); - } - } - _outline_destroy(outline); -} - -static Eina_Bool -_ector_renderer_software_shape_ector_renderer_prepare(Eo *obj, - Ector_Renderer_Software_Shape_Data *pd) -{ - // FIXME: shouldn't this be moved to the software base object? - if (!pd->surface) - pd->surface = efl_data_xref(pd->base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj); - - // Asynchronously lazy build of the RLE data for this shape - if (!pd->task) - { - Ector_Software_Shape_Task *task = _need_update_rle(obj, pd); - if (task) ector_software_schedule(_update_rle, _done_rle, task); - } - - return EINA_TRUE; -} - -static Eina_Bool -_ector_renderer_software_shape_ector_renderer_draw(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Shape_Data *pd, - Efl_Gfx_Render_Op op, Eina_Array *clips, - unsigned int mul_col) -{ - int x, y; - - // check if RLE data are ready - Ector_Software_Shape_Task *task = pd->task; - if (task) ector_software_wait(_update_rle, _done_rle, task); - - // adjust the offset - x = (int)pd->base->origin.x - pd->surface->x; - y = (int)pd->base->origin.y - pd->surface->y; - - ector_software_rasterizer_clip_rect_set(pd->surface->rasterizer, clips); - ector_software_rasterizer_transform_set(pd->surface->rasterizer, pd->base->m); - - // fill the span_data structure - if (pd->shape->fill) - { - ector_renderer_software_op_fill(pd->shape->fill); - ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, - x, y, mul_col, op, - pd->shape_data, - pd->comp, - pd->comp_method); - } - else - { - if (pd->base->color.a > 0) - { - ector_software_rasterizer_color_set(pd->surface->rasterizer, - pd->base->color.r, - pd->base->color.g, - pd->base->color.b, - pd->base->color.a); - ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, - x, y, mul_col, op, - pd->shape_data, - pd->comp, - pd->comp_method); - } - } - - if (!pd->outline_data) return EINA_TRUE; - - if (pd->shape->stroke.fill) - { - ector_renderer_software_op_fill(pd->shape->stroke.fill); - ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, - x, y, mul_col, op, - pd->outline_data, - pd->comp, - pd->comp_method); - } - else - { - if (pd->public_shape->stroke.color.a > 0) - { - ector_software_rasterizer_color_set(pd->surface->rasterizer, - pd->public_shape->stroke.color.r, - pd->public_shape->stroke.color.g, - pd->public_shape->stroke.color.b, - pd->public_shape->stroke.color.a); - ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, - x, y, mul_col, op, - pd->outline_data, - pd->comp, - pd->comp_method); - } - } - - return EINA_TRUE; -} - -static Eina_Bool -_ector_renderer_software_shape_ector_renderer_software_op_fill(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Shape_Data *pd EINA_UNUSED) -{ - // FIXME: let's find out how to fill a shape with a shape later. - // I need to read SVG specification and see how to map that with software. - return EINA_FALSE; -} - -EOLIAN static void -_ector_renderer_software_shape_efl_gfx_path_commit(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Shape_Data *pd) -{ - if (pd->shape_data) - { - ector_software_rasterizer_destroy_rle_data(pd->shape_data); - pd->shape_data = NULL; - } - if (pd->outline_data) - { - ector_software_rasterizer_destroy_rle_data(pd->outline_data); - pd->outline_data = NULL; - } -} - -static Eo * -_ector_renderer_software_shape_efl_object_constructor(Eo *obj, Ector_Renderer_Software_Shape_Data *pd) -{ - obj = efl_constructor(efl_super(obj, MY_CLASS)); - if (!obj) return NULL; - - pd->public_shape = efl_data_xref(obj, EFL_GFX_SHAPE_MIXIN, obj); - pd->shape = efl_data_xref(obj, ECTOR_RENDERER_SHAPE_MIXIN, obj); - pd->base = efl_data_xref(obj, ECTOR_RENDERER_CLASS, obj); - - return obj; -} - -static void -_ector_renderer_software_shape_efl_object_destructor(Eo *obj, Ector_Renderer_Software_Shape_Data *pd) -{ - // FIXME: As base class, destructor can't call destructor of mixin class. - // Call explicit API to free shape data. - if (pd->task) - ector_software_wait(_update_rle, _done_rle, pd->task); - - efl_gfx_path_reset(obj); - - if (pd->shape_data) ector_software_rasterizer_destroy_rle_data(pd->shape_data); - if (pd->outline_data) ector_software_rasterizer_destroy_rle_data(pd->outline_data); - - efl_data_xunref(pd->base->surface, pd->surface, obj); - efl_data_xunref(obj, pd->base, obj); - efl_data_xunref(obj, pd->shape, obj); - efl_data_xunref(obj, pd->public_shape, obj); - - efl_destructor(efl_super(obj, MY_CLASS)); -} - -unsigned int -_ector_renderer_software_shape_ector_renderer_crc_get(const Eo *obj, - Ector_Renderer_Software_Shape_Data *pd) -{ - unsigned int crc; - - crc = ector_renderer_crc_get(efl_super(obj, MY_CLASS)); - - crc = eina_crc((void*) &pd->shape->stroke.marker, - sizeof (pd->shape->stroke.marker), - crc, EINA_FALSE); - crc = eina_crc((void*) &pd->public_shape->stroke.scale, - sizeof (pd->public_shape->stroke.scale) * 3, - crc, EINA_FALSE); // scale, width, centered - crc = eina_crc((void*) &pd->public_shape->stroke.color, - sizeof (pd->public_shape->stroke.color), - crc, EINA_FALSE); - crc = eina_crc((void*) &pd->public_shape->stroke.cap, - sizeof (pd->public_shape->stroke.cap), - crc, EINA_FALSE); - crc = eina_crc((void*) &pd->public_shape->stroke.join, - sizeof (pd->public_shape->stroke.join), - crc, EINA_FALSE); - - if (pd->shape->fill) - crc = _renderer_crc_get(pd->shape->fill, crc); - if (pd->shape->stroke.fill) - crc = _renderer_crc_get(pd->shape->stroke.fill, crc); - if (pd->shape->stroke.marker) - crc = _renderer_crc_get(pd->shape->stroke.marker, crc); - if (pd->public_shape->stroke.dash_length) - { - crc = eina_crc((void*) pd->public_shape->stroke.dash, - sizeof (Efl_Gfx_Dash) * pd->public_shape->stroke.dash_length, - crc, EINA_FALSE); - } - - return crc; -} - -static void -_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->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 deleted file mode 100644 index 83b87c0..0000000 --- a/src/lib/ector/software/ector_renderer_software_shape.eo +++ /dev/null @@ -1,15 +0,0 @@ -class @beta Ector.Renderer.Software.Shape extends Ector.Renderer.Software implements Ector.Renderer.Shape -{ - [[Ector software renderer shape class]] - c_prefix: ector_renderer_software_shape; - implements { - Ector.Renderer.prepare; - Ector.Renderer.draw; - Ector.Renderer.Software.op_fill; - Ector.Renderer.comp_method { set; } - Ector.Renderer.crc { get; } - Efl.Gfx.Path.commit; - Efl.Object.constructor; - Efl.Object.destructor; - } -} diff --git a/src/lib/ector/software/ector_software_gradient.c b/src/lib/ector/software/ector_software_gradient.c deleted file mode 100644 index be20635..0000000 --- a/src/lib/ector/software/ector_software_gradient.c +++ /dev/null @@ -1,214 +0,0 @@ -#include "ector_software_gradient.h" - -#ifdef BUILD_SSE3 -void _radial_helper_sse3(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, float det, float delta_det, float delta_delta_det, float b, float delta_b); -void _linear_helper_sse3(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, int t, int inc); -#endif - -#define GRADIENT_STOPTABLE_SIZE 1024 -#define FIXPT_BITS 8 -#define FIXPT_SIZE (1<alpha = efl_draw_generate_gradient_color_table(gdata->gd->colors, gdata->gd->colors_count, - gdata->color_table, GRADIENT_STOPTABLE_SIZE); -} - -static void -_done_color_table(void *data) -{ - Ector_Renderer_Software_Gradient_Data *gdata = data; - gdata->ctable_status = CTABLE_READY_DONE; -} - -void -ector_software_gradient_color_update(Ector_Renderer_Software_Gradient_Data *gdata) -{ - if (gdata->ctable_status == CTABLE_READY_DONE) return; - - //OPTIMIZE: This color can be updated only when gradient properties are changed. - - //Alloc only one time. - if (!gdata->color_table) - gdata->color_table = malloc(GRADIENT_STOPTABLE_SIZE * 4); - - if (gdata->ctable_status == CTABLE_NOT_READY) - { - gdata->ctable_status = CTABLE_PROCESSING; - ector_software_schedule(_update_color_table, _done_color_table, gdata); - } - else if (gdata->ctable_status == CTABLE_PROCESSING) - ector_software_wait(_update_color_table, _done_color_table, gdata); -} - -void -destroy_color_table(Ector_Renderer_Software_Gradient_Data *gdata) -{ - if (gdata->color_table) - { - free(gdata->color_table); - gdata->color_table = NULL; - } -} - -static void -_linear_helper_generic(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, - int t_fixed, int inc_fixed) -{ - int i; - - for (i = 0 ; i < length ; i++) - { - *buffer++ = _gradient_pixel_fixed(g_data, t_fixed); - t_fixed += inc_fixed; - } -} - -void -fetch_linear_gradient(uint32_t *buffer, Span_Data *data, int y, int x, int length) -{ - Ector_Renderer_Software_Gradient_Data *g_data = data->gradient; - float t, inc, rx=0, ry=0; - uint32_t *end; - int t_fixed, inc_fixed; - - if (EINA_DBL_EQ(g_data->linear.l, 0.0)) - { - t = inc = 0; - } - else - { - rx = data->inv.xy * (y + (float)0.5) + data->inv.xz + data->inv.xx * (x + (float)0.5); - ry = data->inv.yy * (y + (float)0.5) + data->inv.yz + data->inv.yx * (x + (float)0.5); - t = g_data->linear.dx*rx + g_data->linear.dy*ry + g_data->linear.off; - inc = g_data->linear.dx * data->inv.xx + g_data->linear.dx * data->inv.yx; - - t *= (GRADIENT_STOPTABLE_SIZE - 1); - inc *= (GRADIENT_STOPTABLE_SIZE - 1); - } - - end = buffer + length; - if (inc > (float)(-1e-5) && inc < (float)(1e-5)) - { - draw_memset32(buffer, _gradient_pixel_fixed(g_data, (int)(t * FIXPT_SIZE)), length); - } - else - { - const int vmax = INT_MAX >> (FIXPT_BITS + 1); - const int vmin = -vmax; - float v = t + (inc *length); - - if ((v < (float)vmax) && (v > (float)(vmin))) - { - // we can use fixed point math - t_fixed = (int)(t * FIXPT_SIZE); - inc_fixed = (int)(inc * FIXPT_SIZE); - _ector_linear_helper(buffer, length, g_data, t_fixed, inc_fixed); - } - else - { - // we have to fall back to float math - while (buffer < end) - { - *buffer++ = _gradient_pixel(g_data, t/GRADIENT_STOPTABLE_SIZE); - t += inc; - } - } - } -} - -static void -_radial_helper_generic(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, float det, - float delta_det, float delta_delta_det, float b, float delta_b) -{ - int i; - - for (i = 0 ; i < length ; i++) - { - *buffer++ = _gradient_pixel(g_data, sqrt(det) - b); - det += delta_det; - delta_det += delta_delta_det; - b += delta_b; - } -} - - -void -fetch_radial_gradient(uint32_t *buffer, Span_Data *data, int y, int x, int length) -{ - Ector_Renderer_Software_Gradient_Data *g_data = data->gradient; - float rx, ry, inv_a, delta_rx, delta_ry, b, delta_b, b_delta_b, delta_b_delta_b, - bb, delta_bb, rxrxryry, delta_rxrxryry, rx_plus_ry, delta_rx_plus_ry, det, - delta_det, delta_delta_det; - - // avoid division by zero - if (fabsf(g_data->radial.a) <= 0.00001f) - { - draw_memset32(buffer, 0, length); - return; - } - - rx = data->inv.xy * (y + (float)0.5) + data->inv.xz + data->inv.xx * (x + (float)0.5); - ry = data->inv.yy * (y + (float)0.5) + data->inv.yz + data->inv.yx * (x + (float)0.5); - - rx -= g_data->radial.fx; - ry -= g_data->radial.fy; - - inv_a = 1 / (float)(2 * g_data->radial.a); - - delta_rx = data->inv.xx; - delta_ry = data->inv.yx; - - b = 2*(g_data->radial.dr*g_data->radial.fradius + rx * g_data->radial.dx + ry * g_data->radial.dy); - delta_b = 2*(delta_rx * g_data->radial.dx + delta_ry * g_data->radial.dy); - b_delta_b = 2 * b * delta_b; - delta_b_delta_b = 2 * delta_b * delta_b; - - bb = b * b; - delta_bb = delta_b * delta_b; - b *= inv_a; - delta_b *= inv_a; - - rxrxryry = rx * rx + ry * ry; - delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry; - rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry); - delta_rx_plus_ry = 2 * delta_rxrxryry; - - inv_a *= inv_a; - - det = (bb - 4 * g_data->radial.a * (g_data->radial.sqrfr - rxrxryry)) * inv_a; - delta_det = (b_delta_b + delta_bb + 4 * g_data->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a; - delta_delta_det = (delta_b_delta_b + 4 * g_data->radial.a * delta_rx_plus_ry) * inv_a; - - _ector_radial_helper(buffer, length, g_data, det, delta_det, delta_delta_det, b, delta_b); -} - -int -ector_software_gradient_init(void) -{ - static int i = 0; - if (!(i++)) - { - _ector_radial_helper = _radial_helper_generic; - _ector_linear_helper = _linear_helper_generic; -#ifdef BUILD_SSE3 - if (eina_cpu_features_get() & EINA_CPU_SSE3) - { - _ector_radial_helper = _radial_helper_sse3; - _ector_linear_helper = _linear_helper_sse3; - } -#endif - } - return i; -} diff --git a/src/lib/ector/software/ector_software_gradient.h b/src/lib/ector/software/ector_software_gradient.h deleted file mode 100644 index 38731de..0000000 --- a/src/lib/ector/software/ector_software_gradient.h +++ /dev/null @@ -1,67 +0,0 @@ -#ifndef ECTOR_SOFTWARE_GRADIENT_H -# define ECTOR_SOFTWARE_GRADIENT_H - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include -#include - -#include - -#include "ector_private.h" -#include "ector_software_private.h" -#include "draw.h" - -#define GRADIENT_STOPTABLE_SIZE 1024 -#define FIXPT_BITS 8 -#define FIXPT_SIZE (1<gd->s == EFL_GFX_GRADIENT_SPREAD_REPEAT) - { - ipos = ipos % GRADIENT_STOPTABLE_SIZE; - ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos; - } - else if (data->gd->s == EFL_GFX_GRADIENT_SPREAD_REFLECT) - { - limit = GRADIENT_STOPTABLE_SIZE * 2; - ipos = ipos % limit; - ipos = ipos < 0 ? limit + ipos : ipos; - ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - 1 - ipos : ipos; - } - else - { - if (ipos < 0) ipos = 0; - else if (ipos >= GRADIENT_STOPTABLE_SIZE) - ipos = GRADIENT_STOPTABLE_SIZE-1; - } - return ipos; -} - -static inline uint32_t -_gradient_pixel_fixed(const Ector_Renderer_Software_Gradient_Data *data, int fixed_pos) -{ - int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS; - - return data->color_table[_gradient_clamp(data, ipos)]; -} - -static inline uint32_t -_gradient_pixel(const Ector_Renderer_Software_Gradient_Data *data, float pos) -{ - int ipos = (int)(pos * (GRADIENT_STOPTABLE_SIZE - 1) + (float)(0.5)); - - return data->color_table[_gradient_clamp(data, ipos)]; -} - -#endif diff --git a/src/lib/ector/software/ector_software_gradient_sse3.c b/src/lib/ector/software/ector_software_gradient_sse3.c deleted file mode 100644 index 883bdbf..0000000 --- a/src/lib/ector/software/ector_software_gradient_sse3.c +++ /dev/null @@ -1,214 +0,0 @@ -#include "ector_software_gradient.h" - -#ifdef BUILD_SSE3 -#include - -#define GRADIENT_STOPTABLE_SIZE_SHIFT 10 -typedef union { __m128i v; int i[4];} vec4_i; -typedef union { __m128 v; float f[4];} vec4_f; - -#define FETCH_CLAMP_INIT_F \ - __m128 v_min = _mm_set1_ps(0.0f); \ - __m128 v_max = _mm_set1_ps((float)(GRADIENT_STOPTABLE_SIZE-1)); \ - __m128 v_halff = _mm_set1_ps(0.5f); \ - __m128i v_repeat_mask = _mm_set1_epi32(~((uint32_t)(0xffffff) << GRADIENT_STOPTABLE_SIZE_SHIFT)); \ - __m128i v_reflect_mask = _mm_set1_epi32(~((uint32_t)(0xffffff) << (GRADIENT_STOPTABLE_SIZE_SHIFT+1))); \ - __m128i v_reflect_limit = _mm_set1_epi32(2 * GRADIENT_STOPTABLE_SIZE - 1); - -#define FETCH_CLAMP_REPEAT_F \ - vec4_i index_vec; \ - index_vec.v = _mm_and_si128(v_repeat_mask, _mm_cvttps_epi32(v_index)); - -#define FETCH_CLAMP_REFLECT_F \ - vec4_i index_vec; \ - __m128i v_index_i = _mm_and_si128(v_reflect_mask, _mm_cvttps_epi32(v_index)); \ - __m128i v_index_i_inv = _mm_sub_epi32(v_reflect_limit, v_index_i); \ - index_vec.v = _mm_min_epi16(v_index_i, v_index_i_inv); - -#define FETCH_CLAMP_PAD_F \ - vec4_i index_vec; \ - index_vec.v = _mm_cvttps_epi32(_mm_min_ps(v_max, _mm_max_ps(v_min, v_index))); - -#define FETCH_EPILOGUE_CPY \ - *buffer++ = g_data->color_table[index_vec.i[0]]; \ - *buffer++ = g_data->color_table[index_vec.i[1]]; \ - *buffer++ = g_data->color_table[index_vec.i[2]]; \ - *buffer++ = g_data->color_table[index_vec.i[3]]; \ -} - -static void -loop_break(unsigned int *buffer, int length, int *lprealign, int *lby4 , int *lremaining) -{ - int l1=0, l2=0, l3=0; - - while ((uintptr_t)buffer & 0xF) - buffer++ , l1++; - - if(length <= l1) - { - l1 = length; - } - else - { - l3 = (length - l1) % 4; - l2 = length - l1 - l3 ; - } - - *lprealign = l1; - *lby4 = l2; - *lremaining = l3; -} - -void -_radial_helper_sse3(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, - float det, float delta_det, float delta_delta_det, float b, float delta_b) -{ - int lprealign, lby4, lremaining, i; - vec4_f det_vec; - vec4_f delta_det4_vec; - vec4_f b_vec; - __m128 v_delta_delta_det16; - __m128 v_delta_delta_det6; - __m128 v_delta_b4; - - loop_break(buffer, length, &lprealign, &lby4, &lremaining); - - // prealign loop - for (i = 0 ; i < lprealign ; i++) - { - *buffer++ = _gradient_pixel(g_data, sqrt(det) - b); - det += delta_det; - delta_det += delta_delta_det; - b += delta_b; - } - - // lby4 16byte align loop - for (i = 0; i < 4; ++i) - { - det_vec.f[i] = det; - delta_det4_vec.f[i] = 4 * delta_det; - b_vec.f[i] = b; - - det += delta_det; - delta_det += delta_delta_det; - b += delta_b; - } - - v_delta_delta_det16 = _mm_set1_ps(16 * delta_delta_det); - v_delta_delta_det6 = _mm_set1_ps(6 * delta_delta_det); - v_delta_b4 = _mm_set1_ps(4 * delta_b); - -#define FETCH_RADIAL_PROLOGUE \ - for (i = 0 ; i < lby4 ; i+=4) { \ - __m128 v_index_local = _mm_sub_ps(_mm_sqrt_ps(det_vec.v), b_vec.v); \ - __m128 v_index = _mm_add_ps(_mm_mul_ps(v_index_local, v_max), v_halff); \ - det_vec.v = _mm_add_ps(_mm_add_ps(det_vec.v, delta_det4_vec.v), v_delta_delta_det6); \ - delta_det4_vec.v = _mm_add_ps(delta_det4_vec.v, v_delta_delta_det16); \ - b_vec.v = _mm_add_ps(b_vec.v, v_delta_b4); - -#define FETCH_RADIAL_LOOP(FETCH_CLAMP) \ - FETCH_RADIAL_PROLOGUE; \ - FETCH_CLAMP; \ - FETCH_EPILOGUE_CPY; - - FETCH_CLAMP_INIT_F; - switch (g_data->gd->s) - { - case EFL_GFX_GRADIENT_SPREAD_REPEAT: - FETCH_RADIAL_LOOP(FETCH_CLAMP_REPEAT_F); - break; - case EFL_GFX_GRADIENT_SPREAD_REFLECT: - FETCH_RADIAL_LOOP( FETCH_CLAMP_REFLECT_F); - break; - default: - FETCH_RADIAL_LOOP(FETCH_CLAMP_PAD_F); - break; - } - - // remaining loop - for (i = 0 ; i < lremaining ; i++) - *buffer++ = _gradient_pixel(g_data, sqrt(det_vec.f[i]) - b_vec.f[i]); -} - -void -_linear_helper_sse3(uint32_t *buffer, int length, Ector_Renderer_Software_Gradient_Data *g_data, int t, int inc) -{ - int lprealign, lby4, lremaining, i; - vec4_i t_vec; - __m128i v_inc; - __m128i v_fxtpt_size; - __m128i v_min; - __m128i v_max; - __m128i v_repeat_mask; - __m128i v_reflect_mask; - __m128i v_reflect_limit; - - loop_break(buffer, length, &lprealign, &lby4, &lremaining); - - // prealign loop - for (i = 0 ; i < lprealign ; i++) - { - *buffer++ = _gradient_pixel_fixed(g_data, t); - t += inc; - } - - // lby4 16byte align loop - for (i = 0; i < 4; ++i) - { - t_vec.i[i] = t; - t += inc; - } - - v_inc = _mm_set1_epi32(4 * inc); - v_fxtpt_size = _mm_set1_epi32(FIXPT_SIZE * 0.5); - - v_min = _mm_set1_epi32(0); - v_max = _mm_set1_epi32((GRADIENT_STOPTABLE_SIZE - 1)); - - v_repeat_mask = _mm_set1_epi32(~((uint32_t)(0xffffff) << GRADIENT_STOPTABLE_SIZE_SHIFT)); - v_reflect_mask = _mm_set1_epi32(~((uint32_t)(0xffffff) << (GRADIENT_STOPTABLE_SIZE_SHIFT + 1))); - - v_reflect_limit = _mm_set1_epi32(2 * GRADIENT_STOPTABLE_SIZE - 1); - -#define FETCH_LINEAR_LOOP_PROLOGUE \ - for (i = 0 ; i < lby4 ; i+=4) { \ - vec4_i index_vec; \ - __m128i v_index; \ - v_index = _mm_srai_epi32(_mm_add_epi32(t_vec.v, v_fxtpt_size), FIXPT_BITS); \ - t_vec.v = _mm_add_epi32(t_vec.v, v_inc); - -#define FETCH_LINEAR_LOOP_CLAMP_REPEAT \ - index_vec.v = _mm_and_si128(v_repeat_mask, v_index); - -#define FETCH_LINEAR_LOOP_CLAMP_REFLECT \ - __m128i v_index_i = _mm_and_si128(v_reflect_mask, v_index); \ - __m128i v_index_i_inv = _mm_sub_epi32(v_reflect_limit, v_index_i); \ - index_vec.v = _mm_min_epi16(v_index_i, v_index_i_inv); - -#define FETCH_LINEAR_LOOP_CLAMP_PAD \ - index_vec.v = _mm_min_epi16(v_max, _mm_max_epi16(v_min, v_index)); - -#define FETCH_LINEAR_LOOP(FETCH_LINEAR_LOOP_CLAMP) \ - FETCH_LINEAR_LOOP_PROLOGUE; \ - FETCH_LINEAR_LOOP_CLAMP; \ - FETCH_EPILOGUE_CPY; - - switch (g_data->gd->s) - { - case EFL_GFX_GRADIENT_SPREAD_REPEAT: - FETCH_LINEAR_LOOP(FETCH_LINEAR_LOOP_CLAMP_REPEAT); - break; - case EFL_GFX_GRADIENT_SPREAD_REFLECT: - FETCH_LINEAR_LOOP(FETCH_LINEAR_LOOP_CLAMP_REFLECT); - break; - default: - FETCH_LINEAR_LOOP(FETCH_LINEAR_LOOP_CLAMP_PAD); - break; - } - - // remaining loop - for (i = 0 ; i < lremaining ; i++) - *buffer++ = _gradient_pixel_fixed(g_data, t_vec.i[i]); -} - -#endif diff --git a/src/lib/ector/software/ector_software_rasterizer.c b/src/lib/ector/software/ector_software_rasterizer.c deleted file mode 100644 index bbaba48..0000000 --- a/src/lib/ector/software/ector_software_rasterizer.c +++ /dev/null @@ -1,946 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" - -#include "draw.h" - -static void -_blend_argb(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = user_data; - uint32_t color, *buffer, *target; - const int pix_stride = sd->raster_buffer->stride / 4; - - // multiply the color with mul_col if any - color = DRAW_MUL4_SYM(sd->color, sd->mul_col); - RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color); - - // move to the offset location - buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - - while (count--) - { - target = buffer + ((pix_stride * spans->y) + spans->x); - comp_func(target, spans->len, color, spans->coverage); - ++spans; - } -} - -static void -_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 *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - // multiply the color with mul_col if any - 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); - - // move to the offset location - uint32_t *buffer = - sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - uint32_t *mbuffer = comp->pixels.u32; - - //Temp buffer for intermediate processing - int tsize = sd->raster_buffer->generic->w; - uint32_t *tbuffer = alloca(sizeof(uint32_t) * tsize); - - while (count--) - { - uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); - uint32_t *mtarget = - mbuffer + ((comp_stride * spans->y) + spans->x); - uint32_t *temp = tbuffer; - memset(temp, 0x00, sizeof(uint32_t) * spans->len); - comp_func(temp, spans->len, color, spans->coverage); - - //composite - for (int i = 0; i < spans->len; i++) - { - *temp = draw_mul_256(((*mtarget)>>24), *temp); - int alpha = 255 - ((*temp) >> 24); - *target = *temp + draw_mul_256(alpha, *target); - ++temp; - ++mtarget; - ++target; - } - ++spans; - } -} - -static void -_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 *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - // multiply the color with mul_col if any - 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); - - // move to the offset location - uint32_t *buffer = - sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - uint32_t *mbuffer = comp->pixels.u32; - - //Temp buffer for intermediate processing - int tsize = sd->raster_buffer->generic->w; - uint32_t *tbuffer = alloca(sizeof(uint32_t) * tsize); - - while (count--) - { - uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); - uint32_t *mtarget = - mbuffer + ((comp_stride * spans->y) + spans->x); - uint32_t *temp = tbuffer; - memset(temp, 0x00, sizeof(uint32_t) * spans->len); - comp_func(temp, spans->len, color, spans->coverage); - - //composite - for (int i = 0; i < spans->len; i++) - { - if (*mtarget) - *temp = draw_mul_256((255 - ((*mtarget)>>24)), *temp); - int alpha = 255 - ((*temp) >> 24); - *target = *temp + draw_mul_256(alpha, *target); - ++temp; - ++mtarget; - ++target; - } - ++spans; - } -} - -static void -_comp_mask_add(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - 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 = comp->pixels.u32; - - int tsize = sd->raster_buffer->generic->w; - uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - - while (count--) - { - uint32_t *mtarget = mbuffer + ((comp_stride * 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++) - mtarget[i] = draw_mul_256(0xFF - (ttarget[i]>>24), mtarget[i]) + ttarget[i]; - ++spans; - } -} - -static void -_comp_mask_sub(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - 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 = comp->pixels.u32; - - int tsize = sd->raster_buffer->generic->w; - uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - - while (count--) - { - uint32_t *mtarget = mbuffer + ((comp_stride * 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++) - mtarget[i] = draw_mul_256(0xFF - (ttarget[i]>>24), mtarget[i]); - ++spans; - } -} - - -static void -_comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - 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 = comp->pixels.u32; - - int tsize = sd->raster_buffer->generic->w; - uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - - for(unsigned int y = 0; y < comp->generic->h; y++) - { - for(unsigned int x = 0; x < comp->generic->w; x++) - { - 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 + ((comp_stride * 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]); - x += spans->len - 1; - ++spans; - --count; - } - else - { - mbuffer[x + (comp_stride * y)] = (0x00FFFFFF & mbuffer[x + (comp_stride * y)]); - } - } - } -} - - -static void -_comp_mask_diff(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; - const int comp_stride = comp->stride / 4; - - 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 = comp->pixels.u32; - - int tsize = sd->raster_buffer->generic->w; - uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - - while (count--) - { - memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); - uint32_t *mtarget = mbuffer + ((comp_stride * 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]); - ++spans; - } -} - -#define BLEND_GRADIENT_BUFFER_SIZE 2048 - -typedef void (*src_fetch) (unsigned int *buffer, Span_Data *data, int y, int x, int length); - -static void -_blend_gradient(int count, const SW_FT_Span *spans, void *user_data) -{ - RGBA_Comp_Func comp_func; - Span_Data *sd = (Span_Data *)(user_data); - src_fetch fetchfunc = NULL; - unsigned int buffer[BLEND_GRADIENT_BUFFER_SIZE], *target, *destbuffer; - int length, l; - const int pix_stride = sd->raster_buffer->stride / 4; - - // FIXME: Get the proper composition function using ,color, ECTOR_OP etc. - if (sd->type == LinearGradient) fetchfunc = &fetch_linear_gradient; - if (sd->type == RadialGradient) fetchfunc = &fetch_radial_gradient; - - if (!fetchfunc || !sd->raster_buffer->pixels.u32) return; - - comp_func = efl_draw_func_span_get(sd->op, sd->mul_col, sd->gradient->alpha); - - // move to the offset location - destbuffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - - while (count--) - { - target = destbuffer + ((pix_stride * spans->y) + spans->x); - length = spans->len; - while (length) - { - l = MIN(length, BLEND_GRADIENT_BUFFER_SIZE); - //FIXME: span->x must have adding an offset as much as subtracted length... - fetchfunc(buffer, sd, spans->y, spans->x, l); - comp_func(target, buffer, l, sd->mul_col, spans->coverage); - target += l; - length -= l; - } - ++spans; - } -} - -static void -_blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = (Span_Data *)(user_data); - src_fetch fetchfunc = NULL; - uint32_t *buffer; - const int pix_stride = sd->raster_buffer->stride / 4; - uint32_t gbuffer[BLEND_GRADIENT_BUFFER_SIZE]; //gradient buffer - - // FIXME: Get the proper composition function using ,color, ECTOR_OP etc. - if (sd->type == LinearGradient) fetchfunc = &fetch_linear_gradient; - if (sd->type == RadialGradient) fetchfunc = &fetch_radial_gradient; - - if (!fetchfunc) return; - - Ector_Software_Buffer_Base_Data *comp = sd->comp; - uint32_t *mbuffer = comp->pixels.u32; - const int comp_stride = comp->stride / 4; - - // move to the offset location - buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - - while (count--) - { - uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); - uint32_t *mtarget = mbuffer + ((comp_stride * spans->y) + spans->x); - int length = spans->len; - - while (length) - { - int l = MIN(length, BLEND_GRADIENT_BUFFER_SIZE); - //FIXME: span->x must have adding an offset as much as subtracted length... - fetchfunc(gbuffer, sd, spans->y, spans->x, l); - uint32_t *temp = gbuffer; - - for (int i = 0; i < l; i++) - { - *temp = draw_mul_256(((*mtarget)>>24), *temp); - int alpha = 255 - ((*temp) >> 24); - *target = *temp + draw_mul_256(alpha, *target); - ++temp; - ++mtarget; - ++target; - } - length -= l; - } - ++spans; - } -} - -static void -_blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) -{ - Span_Data *sd = (Span_Data *)(user_data); - src_fetch fetchfunc = NULL; - uint32_t *buffer; - const int pix_stride = sd->raster_buffer->stride / 4; - uint32_t gbuffer[BLEND_GRADIENT_BUFFER_SIZE]; //gradient buffer - - // FIXME: Get the proper composition function using ,color, ECTOR_OP etc. - if (sd->type == LinearGradient) fetchfunc = &fetch_linear_gradient; - if (sd->type == RadialGradient) fetchfunc = &fetch_radial_gradient; - - if (!fetchfunc) return; - - Ector_Software_Buffer_Base_Data *comp = sd->comp; - uint32_t *mbuffer = comp->pixels.u32; - const int comp_stride = comp->stride / 4; - - // move to the offset location - buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - - while (count--) - { - uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); - uint32_t *mtarget = mbuffer + ((comp_stride * spans->y) + spans->x); - int length = spans->len; - - while (length) - { - int l = MIN(length, BLEND_GRADIENT_BUFFER_SIZE); - //FIXME: span->x must have adding an offset as much as subtracted length... - fetchfunc(gbuffer, sd, spans->y, spans->x, l); - uint32_t *temp = gbuffer; - - for (int i = 0; i < l; i++) - { - if (*mtarget) - *temp = draw_mul_256((255 - ((*mtarget)>>24)), *temp); - int alpha = 255 - ((*temp) >> 24); - *target = *temp + draw_mul_256(alpha, *target); - ++temp; - ++mtarget; - ++target; - } - length -= l; - } - ++spans; - } -} -/*! - \internal - spans must be sorted on y -*/ -static const -SW_FT_Span *_intersect_spans_rect(const Eina_Rectangle *clip, - const SW_FT_Span *spans, - const SW_FT_Span *end, - SW_FT_Span **out_spans, - int available) -{ - SW_FT_Span *out = *out_spans; - short minx, miny, maxx, maxy; - minx = clip->x; - miny = clip->y; - maxx = minx + clip->w - 1; - maxy = miny + clip->h - 1; - - while (available && spans < end ) - { - if (spans->y > maxy) - { - spans = end;// update spans so that we can breakout - break; - } - if (spans->y < miny - || spans->x > maxx - || spans->x + spans->len <= minx) - { - ++spans; - continue; - } - if (spans->x < minx) - { - out->len = MIN(spans->len - (minx - spans->x), maxx - minx + 1); - out->x = minx; - } - else - { - out->x = spans->x; - out->len = MIN(spans->len, (maxx - spans->x + 1)); - } - if (out->len != 0) - { - out->y = spans->y; - out->coverage = spans->coverage; - ++out; - } - ++spans; - --available; - } - - *out_spans = out; - return spans; -} - -static inline int -_div_255(int x) { return (x + (x>>8) + 0x80) >> 8; } - -static const -SW_FT_Span *_intersect_spans_region(const Shape_Rle_Data *clip, - int *currentClip, - const SW_FT_Span *spans, - const SW_FT_Span *end, - SW_FT_Span **out_spans, - int available) -{ - SW_FT_Span *out = *out_spans; - int sx1, sx2, cx1, cx2, x, len; - - const SW_FT_Span *clipSpans = clip->spans + *currentClip; - const SW_FT_Span *clipEnd = clip->spans + clip->size; - - while (available && spans < end ) - { - if (clipSpans >= clipEnd) - { - spans = end; - break; - } - if (clipSpans->y > spans->y) - { - ++spans; - continue; - } - if (spans->y != clipSpans->y) - { - ++clipSpans; - continue; - } - //assert(spans->y == clipSpans->y); - sx1 = spans->x; - sx2 = sx1 + spans->len; - cx1 = clipSpans->x; - cx2 = cx1 + clipSpans->len; - - if (cx1 < sx1 && cx2 < sx1) - { - ++clipSpans; - continue; - } - else if (sx1 < cx1 && sx2 < cx1) - { - ++spans; - continue; - } - x = MAX(sx1, cx1); - len = MIN(sx2, cx2) - x; - if (len) - { - out->x = MAX(sx1, cx1); - out->len = MIN(sx2, cx2) - out->x; - out->y = spans->y; - out->coverage = _div_255(spans->coverage * clipSpans->coverage); - ++out; - --available; - } - if (sx2 < cx2) - { - ++spans; - } - else - { - ++clipSpans; - } - } - - *out_spans = out; - *currentClip = clipSpans - clip->spans; - return spans; -} - -static void -_span_fill_clipRect(int span_count, const SW_FT_Span *spans, void *user_data) -{ - const int NSPANS = 256; - int clip_count, i; - Span_Data *fill_data = (Span_Data *) user_data; - Clip_Data clip = fill_data->clip; - SW_FT_Span *clipped; - Eina_Rectangle *rect; - Eina_Rectangle tmp_rect; - SW_FT_Span *cspans = NULL; - Eina_Bool intersect = EINA_FALSE; - - //Note: Uses same span_count sized heap memory in intersect mask case. - if (fill_data->comp_method == EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT) - { - intersect = EINA_TRUE; - cspans = malloc(sizeof(SW_FT_Span) * (span_count)); - if (!cspans) - { - ERR("OOM: Failed malloc()"); - return ; - } - } - else - { - cspans = alloca(sizeof(SW_FT_Span) * (NSPANS)); - } - - clip_count = eina_array_count(clip.clips); - - for (i = 0; i < clip_count; i++) - { - rect = (Eina_Rectangle *)eina_array_data_get(clip.clips, i); - - // invert transform the offset - tmp_rect.x = rect->x - fill_data->offx; - tmp_rect.y = rect->y - fill_data->offy; - tmp_rect.w = rect->w; - tmp_rect.h = rect->h; - const SW_FT_Span *end = spans + span_count; - - while (spans < end) - { - clipped = cspans; - spans = _intersect_spans_rect(&tmp_rect, spans, end, &clipped, intersect ? span_count : NSPANS); - if (clipped - cspans) - fill_data->unclipped_blend(clipped - cspans, cspans, fill_data); - } - } - if (intersect && cspans) free(cspans); -} - -static void -_span_fill_clipPath(int span_count, const SW_FT_Span *spans, void *user_data) -{ - const int NSPANS = 256; - int current_clip = 0; - Span_Data *fill_data = (Span_Data *) user_data; - Clip_Data clip = fill_data->clip; - SW_FT_Span *clipped; - SW_FT_Span *cspans = NULL; - Eina_Bool intersect = EINA_FALSE; - - //Note: Uses same span_count sized heap memory in intersect mask case. - if (fill_data->comp_method == EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT) - { - intersect = EINA_TRUE; - cspans = malloc(sizeof(SW_FT_Span) * (span_count)); - if (!cspans) - { - ERR("OOM: Failed malloc()"); - return ; - } - } - else - { - cspans = alloca(sizeof(SW_FT_Span) * (NSPANS)); - } - - // FIXME: Take clip path offset into account. - const SW_FT_Span *end = spans + span_count; - while (spans < end) - { - clipped = cspans; - spans = _intersect_spans_region(clip.path, ¤t_clip, spans, end, &clipped, intersect ? span_count : NSPANS); - if (clipped - cspans) - fill_data->unclipped_blend(clipped - cspans, cspans, fill_data); - } - if (intersect && cspans) free(cspans); -} - -static void -_adjust_span_fill_methods(Span_Data *spdata) -{ - //Blending Function - if (spdata->comp) - { - switch (spdata->comp_method) - { - default: - case EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA: - if (spdata->type == Solid) - 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_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE: - if (spdata->type == Solid) - 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_GFX_VG_COMPOSITE_METHOD_MASK_ADD: - spdata->unclipped_blend = &_comp_mask_add; - break; - case EFL_GFX_VG_COMPOSITE_METHOD_MASK_SUBSTRACT: - spdata->unclipped_blend = &_comp_mask_sub; - break; - case EFL_GFX_VG_COMPOSITE_METHOD_MASK_INTERSECT: - spdata->unclipped_blend = &_comp_mask_ins; - break; - case EFL_GFX_VG_COMPOSITE_METHOD_MASK_DIFFERENCE: - spdata->unclipped_blend = &_comp_mask_diff; - break; - } - } - else - { - if (spdata->type == Solid) - spdata->unclipped_blend = &_blend_argb; - else if (spdata->type == LinearGradient || spdata->type == RadialGradient) - spdata->unclipped_blend = &_blend_gradient; - else //None - spdata->unclipped_blend = NULL; - } - - // Clipping Function - if (spdata->clip.enabled) - { - if (spdata->clip.type == 0) - spdata->blend = &_span_fill_clipRect; - else - spdata->blend = &_span_fill_clipPath; - } - else - spdata->blend = spdata->unclipped_blend; -} - -void ector_software_thread_init(Ector_Software_Thread *thread) -{ - // initialize the rasterizer and stroker - sw_ft_grays_raster.raster_new(&thread->raster); - - SW_FT_Stroker_New(&thread->stroker); - SW_FT_Stroker_Set(thread->stroker, 1 << 6, - SW_FT_STROKER_LINECAP_BUTT, SW_FT_STROKER_LINEJOIN_MITER_FIXED, 0x4<<16); -} - -void ector_software_rasterizer_init(Software_Rasterizer *rasterizer) -{ - //initialize the span data. - rasterizer->fill_data.clip.enabled = EINA_FALSE; - rasterizer->fill_data.unclipped_blend = 0; - rasterizer->fill_data.blend = 0; - efl_draw_init(); - ector_software_gradient_init(); -} - -void ector_software_thread_shutdown(Ector_Software_Thread *thread) -{ - sw_ft_grays_raster.raster_done(thread->raster); - SW_FT_Stroker_Done(thread->stroker); -} - -void ector_software_rasterizer_stroke_set(Ector_Software_Thread *thread, - Software_Rasterizer *rasterizer EINA_UNUSED, double width, - Efl_Gfx_Cap cap_style, Efl_Gfx_Join join_style, - Eina_Matrix3 *m, double miterlimit) -{ - SW_FT_Stroker_LineCap cap; - SW_FT_Stroker_LineJoin join; - int stroke_width; - double scale_factor = 1.0; - - // convert to freetype co-ordinate - SW_FT_Fixed miter_limit = miterlimit * (1<<16); - - if (m) - { - // get the minimum scale factor from matrix - scale_factor = m->xx < m->yy ? m->xx : m->yy; - } - width = width * scale_factor; - width = width/2.0; // as free type uses it as the radius of the - // pen not the diameter. - // convert to freetype co-ordinate - stroke_width = (int)(width * 64); - - switch (cap_style) - { - case EFL_GFX_CAP_SQUARE: - cap = SW_FT_STROKER_LINECAP_SQUARE; - break; - case EFL_GFX_CAP_ROUND: - cap = SW_FT_STROKER_LINECAP_ROUND; - break; - default: - cap = SW_FT_STROKER_LINECAP_BUTT; - break; - } - - switch (join_style) - { - case EFL_GFX_JOIN_BEVEL: - join = SW_FT_STROKER_LINEJOIN_BEVEL; - break; - case EFL_GFX_JOIN_ROUND: - join = SW_FT_STROKER_LINEJOIN_ROUND; - break; - default: - join = SW_FT_STROKER_LINEJOIN_MITER_FIXED; - break; - } - SW_FT_Stroker_Set(thread->stroker, stroke_width, cap, join, miter_limit); -} - -static void -_rle_generation_cb( int count, const SW_FT_Span* spans,void *user) -{ - Shape_Rle_Data *rle = (Shape_Rle_Data *) user; - int newsize = rle->size + count; - - // allocate enough memory for new spans - // alloc is required to prevent free and reallocation - // when the rle needs to be regenerated because of attribute change. - if (rle->alloc < newsize) - { - rle->spans = (SW_FT_Span *) realloc(rle->spans, newsize * sizeof(SW_FT_Span)); - rle->alloc = newsize; - } - - // copy the new spans to the allocated memory - SW_FT_Span *lastspan = (rle->spans + rle->size); - memcpy(lastspan,spans, count * sizeof(SW_FT_Span)); - - // update the size - rle->size = newsize; -} - -Shape_Rle_Data * -ector_software_rasterizer_generate_rle_data(Ector_Software_Thread *thread, - Software_Rasterizer *rasterizer EINA_UNUSED, - SW_FT_Outline *outline) -{ - int i, rle_size; - int l = 0, t = 0, r = 0, b = 0; - Shape_Rle_Data *rle_data = (Shape_Rle_Data *) calloc(1, sizeof(Shape_Rle_Data)); - SW_FT_Raster_Params params; - SW_FT_Span* span; - - params.flags = SW_FT_RASTER_FLAG_DIRECT | SW_FT_RASTER_FLAG_AA ; - params.gray_spans = &_rle_generation_cb; - params.user = rle_data; - params.source = outline; - - sw_ft_grays_raster.raster_render(thread->raster, ¶ms); - - // update RLE bounding box. - span = rle_data->spans; - rle_size = rle_data->size; - if (rle_size) - { - t = span[0].y; - b = span[rle_size-1].y; - for (i = 0; i < rle_size; i++) - { - if (span[i].x < l) l = span[i].x; - if (span[i].x + span[i].len > r) r = span[i].x + span[i].len; - } - rle_data->bbox.x = l; - rle_data->bbox.y = t; - rle_data->bbox.w = r - l; - rle_data->bbox.h = b - t + 1; - } - return rle_data; -} - -Shape_Rle_Data * -ector_software_rasterizer_generate_stroke_rle_data(Ector_Software_Thread *thread, - Software_Rasterizer *rasterizer, - SW_FT_Outline *outline, - Eina_Bool closePath) -{ - uint32_t points,contors; - Shape_Rle_Data *rle_data; - SW_FT_Outline strokeOutline = { 0, 0, NULL, NULL, NULL, 0 }; - - SW_FT_Stroker_ParseOutline(thread->stroker, outline, !closePath); - SW_FT_Stroker_GetCounts(thread->stroker,&points, &contors); - - strokeOutline.points = (SW_FT_Vector *) calloc(points, sizeof(SW_FT_Vector)); - strokeOutline.tags = (char *) calloc(points, sizeof(char)); - strokeOutline.contours = (short *) calloc(contors, sizeof(short)); - - SW_FT_Stroker_Export(thread->stroker, &strokeOutline); - - rle_data = ector_software_rasterizer_generate_rle_data(thread, rasterizer, &strokeOutline); - - // cleanup the outline data. - free(strokeOutline.points); - free(strokeOutline.tags); - free(strokeOutline.contours); - - return rle_data; -} - -void -ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle) -{ - if (rle) - { - if (rle->spans) - free(rle->spans); - free(rle); - } -} - -static -void _setup_span_fill_matrix(Software_Rasterizer *rasterizer) -{ - if (rasterizer->transform) - eina_matrix3_inverse(rasterizer->transform, &rasterizer->fill_data.inv); - else - eina_matrix3_identity(&rasterizer->fill_data.inv); -} - -void -ector_software_rasterizer_transform_set(Software_Rasterizer *rasterizer, Eina_Matrix3 *t) -{ - rasterizer->transform = t; -} - -void -ector_software_rasterizer_clip_rect_set(Software_Rasterizer *rasterizer, Eina_Array *clips) -{ - if (clips) - { - rasterizer->fill_data.clip.clips = clips; - rasterizer->fill_data.clip.type = 0; - rasterizer->fill_data.clip.enabled = EINA_TRUE; - } - else - { - rasterizer->fill_data.clip.clips = NULL; - rasterizer->fill_data.clip.type = 0; - rasterizer->fill_data.clip.enabled = EINA_FALSE; - } -} - -void -ector_software_rasterizer_clip_shape_set(Software_Rasterizer *rasterizer, Shape_Rle_Data *clip) -{ - if (clip) - { - rasterizer->fill_data.clip.path = clip; - rasterizer->fill_data.clip.type = 1; - rasterizer->fill_data.clip.enabled = EINA_TRUE; - } - else - { - rasterizer->fill_data.clip.path = NULL; - rasterizer->fill_data.clip.type = 0; - rasterizer->fill_data.clip.enabled = EINA_FALSE; - } -} - -void -ector_software_rasterizer_color_set(Software_Rasterizer *rasterizer, int r, int g, int b, int a) -{ - rasterizer->fill_data.color = DRAW_ARGB_JOIN(a, r, g, b); - rasterizer->fill_data.type = Solid; -} - -void ector_software_rasterizer_linear_gradient_set(Software_Rasterizer *rasterizer, - Ector_Renderer_Software_Gradient_Data *linear) -{ - rasterizer->fill_data.gradient = linear; - rasterizer->fill_data.type = LinearGradient; -} - -void -ector_software_rasterizer_radial_gradient_set(Software_Rasterizer *rasterizer, - Ector_Renderer_Software_Gradient_Data *radial) -{ - rasterizer->fill_data.gradient = radial; - rasterizer->fill_data.type = RadialGradient; -} - -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 *comp, - Efl_Gfx_Vg_Composite_Method comp_method) -{ - if (!rle) return; - if (!rasterizer->fill_data.raster_buffer->pixels.u32) return; - - rasterizer->fill_data.offx = x; - rasterizer->fill_data.offy = y; - rasterizer->fill_data.mul_col = mul_col; - rasterizer->fill_data.op = 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); - - if (rasterizer->fill_data.blend) - rasterizer->fill_data.blend(rle->size, rle->spans, &rasterizer->fill_data); -} diff --git a/src/lib/ector/software/ector_software_surface.c b/src/lib/ector/software/ector_software_surface.c deleted file mode 100644 index ba64445..0000000 --- a/src/lib/ector/software/ector_software_surface.c +++ /dev/null @@ -1,288 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include - -#include "ector_private.h" -#include "ector_software_private.h" - -#define MY_CLASS ECTOR_SOFTWARE_SURFACE_CLASS - -typedef struct _Ector_Software_Task Ector_Software_Task; - -struct _Ector_Software_Task -{ - Eina_Thread_Queue_Msg member; - - Ector_Thread_Worker_Cb cb; - Eina_Free_Cb done; - void *data; -}; - -static int _count_init = 0; -static unsigned int current = 0; -static unsigned int cpu_core = 0; -static Ector_Software_Thread *ths = NULL; -static Eina_Thread_Queue *render_queue = NULL; -static Ector_Software_Thread render_thread; - -static void * -_prepare_process(void *data, Eina_Thread t) -{ - Ector_Software_Thread *th = data; - - eina_thread_name_set(t, "Ector Preparing Thread"); - do - { - Ector_Software_Task *task, todo; - void *ref; - - task = eina_thread_queue_wait(th->queue, &ref); - - if (!task) break ; - todo.cb = task->cb; - todo.data = task->data; - todo.done = task->done; - - eina_thread_queue_wait_done(th->queue, ref); - - if (!todo.cb) break ; - - todo.cb(todo.data, th); - - task = eina_thread_queue_send(render_queue, sizeof (Ector_Software_Task), &ref); - task->cb = todo.cb; - task->data = todo.data; - task->done = todo.done; - eina_thread_queue_send_done(render_queue, ref); - } - while (1); - - return th; -} - - -static void -_ector_software_init(void) -{ - int cpu, i; - - ++_count_init; - if (_count_init != 1) return; - - cpu = eina_cpu_count() - 1; - if (cpu < 1) - { - render_thread.queue = NULL; - ector_software_thread_init(&render_thread); - return ; - } - cpu = cpu > 8 ? 8 : cpu; - cpu_core = cpu; - - render_queue = eina_thread_queue_new(); - - ths = malloc(sizeof(Ector_Software_Thread) * cpu); - for (i = 0; i < cpu; i++) - { - Ector_Software_Thread *t; - - t = &ths[i]; - t->queue = eina_thread_queue_new(); - ector_software_thread_init(t); - if (!eina_thread_create(&t->thread, EINA_THREAD_NORMAL, -1, - _prepare_process, t)) - { - eina_thread_queue_free(t->queue); - t->queue = NULL; - } - } -} - -static void -_ector_software_shutdown(void) -{ - Ector_Software_Thread *t; - unsigned int i; - - --_count_init; - if (_count_init != 0) return; - - if (!ths) - { - ector_software_thread_shutdown(&render_thread); - return ; - } - - for (i = 0; i < cpu_core; i++) - { - Ector_Software_Task *task; - void *ref; - - t = &ths[i]; - - task = eina_thread_queue_send(t->queue, sizeof (Ector_Software_Task), &ref); - task->cb = NULL; - task->data = NULL; - eina_thread_queue_send_done(t->queue, ref); - - eina_thread_join(t->thread); - eina_thread_queue_free(t->queue); - ector_software_thread_shutdown(t); - } - - eina_thread_queue_free(render_queue); - render_queue = NULL; - - free(ths); - ths = NULL; -} - -void -ector_software_schedule(Ector_Thread_Worker_Cb cb, Eina_Free_Cb done, void *data) -{ - Ector_Software_Thread *t; - Ector_Software_Task *task; - void *ref; - - // Not enough CPU, doing it inline in the rendering thread - if (!ths) return ; - - t = &ths[current]; - current = (current + 1) % cpu_core; - - task = eina_thread_queue_send(t->queue, sizeof (Ector_Software_Task), &ref); - task->cb = cb; - task->done = done; - task->data = data; - eina_thread_queue_send_done(t->queue, ref); -} - -// Do not call this function if the done function has already called -void -ector_software_wait(Ector_Thread_Worker_Cb cb, Eina_Free_Cb done, void *data) -{ - Ector_Software_Task *task, covering; - - // First handle case with just inlined prepare code call inside the rendering thread - if (!ths) - { - render_thread.thread = eina_thread_self(); - cb(data, &render_thread); - done(data); - - return ; - } - - // We don't know which task is going to be done first, so - // we iterate until we find ourself back and trigger all - // the done call along the way. - do - { - void *ref; - - task = eina_thread_queue_wait(render_queue, &ref); - if (!task) break; - covering.cb = task->cb; - covering.done = task->done; - covering.data = task->data; - eina_thread_queue_wait_done(render_queue, ref); - - covering.done(covering.data); - } - while (covering.cb != cb || - covering.done != done || - covering.data != data); -} - -static Ector_Renderer * -_ector_software_surface_ector_surface_renderer_factory_new(Eo *obj, - Ector_Software_Surface_Data *pd EINA_UNUSED, - const Efl_Class *type) -{ - if (type == ECTOR_RENDERER_SHAPE_MIXIN) - return efl_add_ref(ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS, NULL, ector_renderer_surface_set(efl_added, obj)); - else if (type == ECTOR_RENDERER_IMAGE_MIXIN) - return efl_add_ref(ECTOR_RENDERER_SOFTWARE_IMAGE_CLASS, NULL, ector_renderer_surface_set(efl_added, obj)); - else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN) - return efl_add_ref(ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(efl_added, obj)); - else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN) - return efl_add_ref(ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS, NULL, ector_renderer_surface_set(efl_added, obj)); - - ERR("Couldn't find class for type: %s", efl_class_name_get(type)); - return NULL; -} - -static Eo * -_ector_software_surface_efl_object_constructor(Eo *obj, Ector_Software_Surface_Data *pd) -{ - _ector_software_init(); - - obj = efl_constructor(efl_super(obj, MY_CLASS)); - pd->rasterizer = (Software_Rasterizer *) calloc(1, sizeof(Software_Rasterizer)); - ector_software_rasterizer_init(pd->rasterizer); - pd->rasterizer->fill_data.raster_buffer = efl_data_ref(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN); - return obj; -} - -static void -_ector_software_surface_efl_object_destructor(Eo *obj, Ector_Software_Surface_Data *pd) -{ - efl_data_unref(obj, pd->rasterizer->fill_data.raster_buffer); - free(pd->rasterizer); - pd->rasterizer = NULL; - efl_destructor(efl_super(obj, ECTOR_SOFTWARE_SURFACE_CLASS)); - - _ector_software_shutdown(); -} - -static void -_ector_software_surface_ector_surface_reference_point_get(const Eo *obj EINA_UNUSED, - Ector_Software_Surface_Data *pd, - int* x, int* y) -{ - if (x) *x = pd->x; - if (y) *y = pd->y; -} - -static void -_ector_software_surface_ector_surface_reference_point_set(Eo *obj EINA_UNUSED, - Ector_Software_Surface_Data *pd, - int x, int y) -{ - pd->x = x; - pd->y = y; -} - -static Eina_Bool -_ector_software_surface_ector_surface_draw_image(Eo *obj EINA_UNUSED, - Ector_Software_Surface_Data *pd, - Ector_Buffer *buffer, int x, int y, int alpha) -{ - if (!buffer || !pd->rasterizer || !pd->rasterizer->fill_data.raster_buffer->pixels.u32) - return EINA_FALSE; - - Ector_Software_Buffer_Base_Data *bd = efl_data_scope_get(buffer, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN); - const int pix_stride = pd->rasterizer->fill_data.raster_buffer->stride / 4; - - uint32_t *src = bd->pixels.u32; - if (!src) return EINA_FALSE; - - for (unsigned int local_y = 0; local_y < bd->generic->h; local_y++) - { - uint32_t *dst = pd->rasterizer->fill_data.raster_buffer->pixels.u32 + (x + ((local_y + y) * pix_stride)); - for (unsigned int local_x = 0; local_x < bd->generic->w; local_x++) - { - *src = draw_mul_256(alpha, *src); - int inv_alpha = 255 - ((*src) >> 24); - *dst = *src + draw_mul_256(inv_alpha, *dst); - dst++; - src++; - } - } - return EINA_TRUE; -} -#include "ector_software_surface.eo.c" -#include "ector_renderer_software.eo.c" diff --git a/src/lib/ector/software/ector_software_surface.eo b/src/lib/ector/software/ector_software_surface.eo deleted file mode 100644 index 5836951..0000000 --- a/src/lib/ector/software/ector_software_surface.eo +++ /dev/null @@ -1,13 +0,0 @@ -class @beta Ector.Software.Surface extends Ector.Software.Buffer implements Ector.Surface -{ - [[Ector surface software class]] - c_prefix: ector_software_surface; - methods {} - implements { - Ector.Surface.renderer_factory_new; - Ector.Surface.reference_point { set; get; } - Ector.Surface.draw_image; - Efl.Object.destructor; - Efl.Object.constructor; - } -} diff --git a/src/lib/ector/software/meson.build b/src/lib/ector/software/meson.build index 75d2171..5345adc 100644 --- a/src/lib/ector/software/meson.build +++ b/src/lib/ector/software/meson.build @@ -1,25 +1,12 @@ ector_src += files([ - 'ector_renderer_software_gradient_linear.c', - 'ector_renderer_software_gradient_radial.c', - 'ector_renderer_software_shape.c', - 'ector_renderer_software_image.c', - 'ector_software_gradient.c', - 'ector_software_rasterizer.c', - 'ector_software_surface.c', 'ector_software_buffer.c', ]) pub_eo_files = [ - 'ector_software_surface.eo', 'ector_software_buffer.eo', 'ector_software_buffer_base.eo', - 'ector_renderer_software.eo', - 'ector_renderer_software_shape.eo', - 'ector_renderer_software_image.eo', - 'ector_renderer_software_gradient_radial.eo', - 'ector_renderer_software_gradient_linear.eo', ] foreach eo_file : pub_eo_files @@ -37,17 +24,6 @@ foreach eo_file : pub_eo_files endforeach -if cpu_sse3 == true - ector_opt = static_library('ector_opt', - sources: pub_eo_file_target + [ 'ector_software_gradient_sse3.c' ], - dependencies: ector_pub_deps + [triangulator, freetype, draw, m] + ector_deps, - include_directories: config_dir + [ include_directories('..') ], - c_args: native_arch_opt_c_args, - ) - ector_opt_lib += [ ector_opt ] -endif - - # # Only enable that again when the namespace problems are fixed. ref T8648 # diff --git a/src/modules/evas/engines/gl_generic/evas_engine.c b/src/modules/evas/engines/gl_generic/evas_engine.c index bdd1869..28c1b54 100755 --- a/src/modules/evas/engines/gl_generic/evas_engine.c +++ b/src/modules/evas/engines/gl_generic/evas_engine.c @@ -1,7 +1,6 @@ #include "evas_common_private.h" #include "evas_gl_core_private.h" -#include "software/Ector_Software.h" #include "gl/Ector_GL.h" #include "evas_ector_gl.h" #include "filters/gl_engine_filter.h" @@ -2747,8 +2746,6 @@ eng_ector_create(void *engine EINA_UNUSED) ector = efl_add_ref(ECTOR_GL_SURFACE_CLASS, NULL); use_gl = EINA_TRUE; } - else - ector = efl_add_ref(ECTOR_SOFTWARE_SURFACE_CLASS, NULL); efl_domain_current_pop(); return ector; diff --git a/src/modules/evas/engines/software_generic/evas_engine.c b/src/modules/evas/engines/software_generic/evas_engine.c index 8d27410..02fb636 100755 --- a/src/modules/evas/engines/software_generic/evas_engine.c +++ b/src/modules/evas/engines/software_generic/evas_engine.c @@ -4,7 +4,6 @@ #include "region.h" -#include #include "evas_ector_software.h" #include "draw.h" #include "evas_filter_private.h" @@ -409,12 +408,6 @@ struct _Evas_Thread_Command_Ector Eina_Bool free_it; }; -struct _Evas_Thread_Command_Ector_Surface -{ - Ector_Surface *ector; - void *pixels; - int x, y; -}; // declare here as it is re-used static void *eng_image_map_surface_new(void *data, int w, int h, int alpha); @@ -426,8 +419,6 @@ Eina_Mempool *_mp_command_image = NULL; Eina_Mempool *_mp_command_font = NULL; Eina_Mempool *_mp_command_map = NULL; Eina_Mempool *_mp_command_multi_font = NULL; -Eina_Mempool *_mp_command_ector = NULL; -Eina_Mempool *_mp_command_ector_surface = NULL; /* ***** ** @@ -4383,63 +4374,39 @@ eng_output_idle_flush(void *engine EINA_UNUSED, void *data) static Ector_Surface * eng_ector_create(void *engine EINA_UNUSED) { - Ector_Surface *ector; - - efl_domain_current_push(EFL_ID_DOMAIN_SHARED); - ector = efl_add_ref(ECTOR_SOFTWARE_SURFACE_CLASS, NULL); - efl_domain_current_pop(); - return ector; + return NULL; } static void* -eng_ector_surface_create(void *engine, int width, int height, int *error) +eng_ector_surface_create(void *engine EINA_UNUSED, int width EINA_UNUSED, int height EINA_UNUSED, int *error EINA_UNUSED) { - void *surface; - - *error = EINA_FALSE; - - surface = eng_image_new_from_copied_data(engine, width, height, NULL, EINA_TRUE, EVAS_COLORSPACE_ARGB8888); - if (!surface) *error = EINA_TRUE; - - return surface; + return NULL; } static void -eng_ector_surface_destroy(void *engine, void *surface) +eng_ector_surface_destroy(void *engine EINA_UNUSED, void *surface EINA_UNUSED) { - if (!surface) return; - eng_image_free(engine, surface); } static void -eng_ector_surface_cache_set(void *engine, void *key , void *surface) +eng_ector_surface_cache_set(void *engine EINA_UNUSED, void *key EINA_UNUSED, void *surface EINA_UNUSED) { - Render_Engine_Software_Generic *e = engine; - - generic_cache_data_set(e->surface_cache, key, surface); - } static void * -eng_ector_surface_cache_get(void *engine, void *key) +eng_ector_surface_cache_get(void *engine EINA_UNUSED, void *key EINA_UNUSED) { - Render_Engine_Software_Generic *e = engine; - - return generic_cache_data_get(e->surface_cache, key); + return NULL; } static void -eng_ector_surface_cache_drop(void *engine, void *key) +eng_ector_surface_cache_drop(void *engine EINA_UNUSED, void *key EINA_UNUSED) { - Render_Engine_Software_Generic *e = engine; - - generic_cache_data_drop(e->surface_cache, key); } static void -eng_ector_destroy(void *data EINA_UNUSED, Ector_Surface *ector) +eng_ector_destroy(void *data EINA_UNUSED, Ector_Surface *ector EINA_UNUSED) { - if (ector) efl_unref(ector); } static Ector_Buffer * @@ -4495,186 +4462,17 @@ eng_ector_buffer_new(void *data, Evas *evas, int width, int height, } static void -_draw_thread_ector_cleanup(Evas_Thread_Command_Ector *ector) -{ - Eina_Rectangle *r; - - while ((r = eina_array_pop(ector->clips))) - eina_rectangle_free(r); - eina_array_free(ector->clips); - - if (ector->free_it) - eina_mempool_free(_mp_command_ector, ector); -} - -static void -_draw_thread_ector_draw(void *data) +eng_ector_renderer_draw(void *engine EINA_UNUSED, void *surface EINA_UNUSED, + void *context EINA_UNUSED, Ector_Renderer *renderer EINA_UNUSED, + Eina_Array *clips EINA_UNUSED, Eina_Bool do_async EINA_UNUSED) { - Evas_Thread_Command_Ector *ector = data; - - ector_renderer_draw(ector->r, ector->render_op, ector->clips, ector->mul_col); - - _draw_thread_ector_cleanup(ector); -} - -static void -eng_ector_renderer_draw(void *engine EINA_UNUSED, void *surface, - void *context, Ector_Renderer *renderer, - Eina_Array *clips, Eina_Bool do_async) -{ - RGBA_Image *dst = surface; - RGBA_Draw_Context *dc = context; - Evas_Thread_Command_Ector ector; - Eina_Array *c; - Eina_Rectangle *r; - Eina_Rectangle clip; - Eina_Array_Iterator it; - unsigned int i; - - if (dc->clip.use) - { - clip.x = dc->clip.x; - clip.y = dc->clip.y; - clip.w = dc->clip.w; - clip.h = dc->clip.h; - // clip the clip rect to surface boundary. - RECTS_CLIP_TO_RECT(clip.x, clip.y, clip.w, clip.h, 0, 0, dst->cache_entry.w, dst->cache_entry.h); - if ((clip.w < 1) || (clip.h < 1)) return; - } - else - { - clip.x = 0; - clip.y = 0; - clip.w = dst->cache_entry.w; - clip.h = dst->cache_entry.h; - } - - c = eina_array_new(8); - if (clips) - { - EINA_ARRAY_ITER_NEXT(clips, i, r, it) - { - Eina_Rectangle *rc; - - rc = eina_rectangle_new(r->x, r->y, r->w, r->h); - if (!rc) continue; - - if (eina_rectangle_intersection(rc, &clip)) - eina_array_push(c, rc); - else - eina_rectangle_free(rc); - } - - if (eina_array_count(c) == 0 && - eina_array_count(clips) > 0) - { - eina_array_free(c); - return; - } - } - - if (eina_array_count(c) == 0) - eina_array_push(c, eina_rectangle_new(clip.x, clip.y, clip.w, clip.h)); - - ector.r = renderer; // This has already been refcounted by Evas_Object_VG - ector.clips = c; - ector.render_op = EFL_GFX_RENDER_OP_BLEND; - ector.mul_col = 0xffffffff; - ector.free_it = EINA_FALSE; - - if (do_async) - { - Evas_Thread_Command_Ector *ne; - - ne = eina_mempool_malloc(_mp_command_ector, sizeof (Evas_Thread_Command_Ector)); - if (!ne) - { - _draw_thread_ector_cleanup(&ector); - return; - } - - memcpy(ne, &ector, sizeof (Evas_Thread_Command_Ector)); - ne->free_it = EINA_TRUE; - - QCMD(_draw_thread_ector_draw, ne); - } - else - { - _draw_thread_ector_draw(&ector); - } -} - -static void -_draw_thread_ector_surface_set(void *data) -{ - Evas_Thread_Command_Ector_Surface *ector_surface = data; - RGBA_Image *surface = ector_surface->pixels; - void *pixels = NULL; - unsigned int w = 0; - unsigned int h = 0; - unsigned int x = 0; - unsigned int y = 0; - - // flush the cpu pipeline before ector drawing. - evas_common_cpu_end_opt(); - - if (surface) - { - pixels = evas_cache_image_pixels(&surface->cache_entry); - if (pixels) - { - w = surface->cache_entry.w; - h = surface->cache_entry.h; - x = ector_surface->x; - y = ector_surface->y; - // clear the surface before giving to ector - memset(pixels, 0, (w * h * 4)); - } - } - - ector_buffer_pixels_set(ector_surface->ector, pixels, w, h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); - ector_surface_reference_point_set(ector_surface->ector, x, y); - - eina_mempool_free(_mp_command_ector_surface, ector_surface); } static Eina_Bool -eng_ector_begin(void *engine EINA_UNUSED, void *surface, - void *context EINA_UNUSED, Ector_Surface *ector, - int x, int y, Eina_Bool do_async) +eng_ector_begin(void *engine EINA_UNUSED, void *surface EINA_UNUSED, + void *context EINA_UNUSED, Ector_Surface *ector EINA_UNUSED, + int x EINA_UNUSED, int y EINA_UNUSED, Eina_Bool do_async EINA_UNUSED) { - if (do_async) - { - Evas_Thread_Command_Ector_Surface *nes; - - nes = eina_mempool_malloc(_mp_command_ector_surface, sizeof (Evas_Thread_Command_Ector_Surface)); - if (!nes) return EINA_FALSE; - - nes->ector = ector; - nes->pixels = surface; - nes->x = x; - nes->y = y; - - QCMD(_draw_thread_ector_surface_set, nes); - } - else - { - RGBA_Image *sf = surface; - void *pixels = NULL; - unsigned int w = 0; - unsigned int h = 0; - - pixels = evas_cache_image_pixels(&sf->cache_entry); - if (!pixels) return EINA_FALSE; - - w = sf->cache_entry.w; - h = sf->cache_entry.h; - // clear the surface before giving to ector - memset(pixels, 0, (w * h * 4)); - - ector_buffer_pixels_set(ector, pixels, w, h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); - ector_surface_reference_point_set(ector, x, y); - } return EINA_TRUE; } @@ -4682,26 +4480,9 @@ static void eng_ector_end(void *engine EINA_UNUSED, void *surface EINA_UNUSED, void *context EINA_UNUSED, - Ector_Surface *ector, - Eina_Bool do_async) + Ector_Surface *ector EINA_UNUSED, + Eina_Bool do_async EINA_UNUSED) { - if (do_async) - { - Evas_Thread_Command_Ector_Surface *nes; - - nes = eina_mempool_malloc(_mp_command_ector_surface, sizeof (Evas_Thread_Command_Ector_Surface)); - if (!nes) return ; - - nes->ector = ector; - nes->pixels = NULL; - - QCMD(_draw_thread_ector_surface_set, nes); - } - else - { - ector_buffer_pixels_set(ector, NULL, 0, 0, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); - evas_common_cpu_end_opt(); - } } //------------------------------------------------// @@ -6075,17 +5856,10 @@ module_open(Evas_Module *em) _mp_command_multi_font = eina_mempool_add("chained_mempool", "Evas_Thread_Command_Multi_Font", NULL, sizeof(Evas_Thread_Command_Multi_Font), 128); - _mp_command_ector = - eina_mempool_add("chained_mempool", "Evas_Thread_Command_Ector", - NULL, sizeof(Evas_Thread_Command_Ector), 128); - _mp_command_ector_surface = - eina_mempool_add("chained_mempool", "Evas_Thread_Command_Ector_Surface", - NULL, sizeof(Evas_Thread_Command_Ector_Surface), 128); ector_init(); // do on demand when first evas_gl_api_get is called... // init_gl(); - ector_glsym_set(dlsym, RTLD_DEFAULT); evas_common_pipe_init(); em->functions = (void *)(&func); @@ -6103,7 +5877,6 @@ module_close(Evas_Module *em EINA_UNUSED) eina_mempool_del(_mp_command_image); eina_mempool_del(_mp_command_font); eina_mempool_del(_mp_command_map); - eina_mempool_del(_mp_command_ector); if (_evas_soft_gen_log_dom >= 0) { eina_log_domain_unregister(_evas_soft_gen_log_dom); -- 2.7.4