kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Ector: Move drawhelper to static_libs 

Rename a few things:
 - draw helper -> efl_draw
 - Ector_Rop -> Efl.Gfx.Render_Op
 - ECTOR_ bla bla -> DRAW_ bla bla (base pixel ops)
 - ector_memfill -> draw_memset32 (and invert arg order to match memset)

The main rasterizer file is now draw.h in static_libs/draw
This is a non functional change, simple code refactor.
This commit is contained in:
Jean-Philippe Andre 2015-12-02 18:46:29 +09:00
parent bad7911cd0
commit 615b2442b7
29 changed files with 240 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/Makefile_Ector.am
View File

@ -90,6 +90,13 @@ lib/ector/cairo/ector_cairo_surface.c
installed_ectorcairoheadersdir = $(includedir)/ector-@VMAJ@/cairo
nodist_installed_ectorcairoheaders_DATA = $(ector_eolian_cairo_h)
# SW draw static lib
draw_sources = \
static_libs/draw/draw_main_sse2.c \
static_libs/draw/draw_main.c \
static_libs/draw/draw_main_neon.c \
$(NULL)
# And the default software backend
lib_ector_libector_la_SOURCES += \
lib/ector/software/ector_renderer_software_gradient_linear.c \
@ -103,9 +110,7 @@ lib/ector/software/ector_software_buffer.c \
static_libs/freetype/sw_ft_math.c \
static_libs/freetype/sw_ft_raster.c \
static_libs/freetype/sw_ft_stroker.c \
lib/ector/software/ector_drawhelper.c \
lib/ector/software/ector_drawhelper_sse2.c \
lib/ector/software/ector_drawhelper_neon.c
$(draw_sources)
installed_ectorsoftwareheadersdir = $(includedir)/ector-@VMAJ@/software
nodist_installed_ectorsoftwareheaders_DATA = $(ector_eolian_software_h)
@ -115,6 +120,7 @@ lib_ector_libector_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
-I$(top_builddir)/src/lib/ector/cairo \
-I$(top_builddir)/src/lib/ector/software \
-I$(top_srcdir)/src/static_libs/freetype \
-I$(top_srcdir)/src/static_libs/draw \
@ECTOR_CFLAGS@ \
-DPACKAGE_BIN_DIR=\"$(bindir)\" \
-DPACKAGE_LIB_DIR=\"$(libdir)\" \
@ -165,4 +171,6 @@ lib/ector/software/ector_software_private.h \
static_libs/freetype/sw_ft_math.h \
static_libs/freetype/sw_ft_raster.h \
static_libs/freetype/sw_ft_stroker.h \
static_libs/freetype/sw_ft_types.h
static_libs/freetype/sw_ft_types.h \
static_libs/draw/draw.h \
static_libs/draw/draw_private.h

2
src/Makefile_Efl.am
View File

@ -1,6 +1,7 @@
# Even though libefl is new, it contains definitions used by legacy APIs
efl_eolian_legacy_files = \
lib/efl/interfaces/efl_gfx_fill.eo \
lib/efl/interfaces/efl_gfx_base.eo \
$(NULL)
efl_eolian_files = \
@ -10,7 +11,6 @@ efl_eolian_files = \
lib/efl/interfaces/efl_player.eo \
lib/efl/interfaces/efl_text.eo \
lib/efl/interfaces/efl_text_properties.eo \
lib/efl/interfaces/efl_gfx_base.eo \
lib/efl/interfaces/efl_gfx_stack.eo \
lib/efl/interfaces/efl_gfx_view.eo \
lib/efl/interfaces/efl_gfx_shape.eo \

1
src/Makefile_Evas.am
View File

@ -349,6 +349,7 @@ lib_evas_libevas_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
-I$(top_srcdir)/src/lib/evas/file \
-I$(top_srcdir)/src/lib/evas/include \
-I$(top_srcdir)/src/static_libs/libunibreak \
-I$(top_srcdir)/src/static_libs/draw \
-I$(top_builddir)/src/lib/evas/canvas \
-I$(top_builddir)/src/modules/evas/engines/software_generic \
-I$(top_builddir)/src/modules/evas/engines/gl_generic \

10
src/lib/ector/Ector.h
View File

@ -113,16 +113,6 @@ typedef Eo Ector_Renderer;
// FIXME: Enable that when we have merged Emile
/* typedef Evas_Colorspace Ector_Colorspace; */
/**
* Raster operations at pixel level
*/
typedef enum _Ector_Rop
{
ECTOR_ROP_BLEND, /**< D = S + D(1 - Sa) */
ECTOR_ROP_COPY, /**< D = S */
ECTOR_ROP_LAST
} Ector_Rop;
/**
* Quality values
*/

2
src/lib/ector/cairo/ector_cairo_private.h
View File

@ -1,6 +1,8 @@
#ifndef ECTOR_CAIRO_PRIVATE_H_
# define ECTOR_CAIRO_PRIVATE_H_
#include "draw.h"
typedef void cairo_pattern_t;
typedef struct {

6
src/lib/ector/cairo/ector_renderer_cairo_base.c
View File

@ -121,7 +121,7 @@ _ector_renderer_cairo_base_ector_renderer_generic_base_prepare(Eo *obj, Ector_Re
static Eina_Bool
_ector_renderer_cairo_base_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
Ector_Renderer_Cairo_Base_Data *pd,
Ector_Rop op,
Efl_Gfx_Render_Op op,
Eina_Array *clips EINA_UNUSED,
unsigned int mul_col)
{
@ -131,10 +131,10 @@ _ector_renderer_cairo_base_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
switch (op)
{
case ECTOR_ROP_BLEND:
case EFL_GFX_RENDER_OP_BLEND:
cop = CAIRO_OPERATOR_OVER;
break;
case ECTOR_ROP_COPY:
case EFL_GFX_RENDER_OP_COPY:
default:
cop = CAIRO_OPERATOR_SOURCE;
break;

2
src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
View File

@ -64,7 +64,7 @@ _ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_prepare(Eo *ob
static Eina_Bool
_ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_draw(Eo *obj,
Ector_Renderer_Cairo_Gradient_Linear_Data *pd,
Ector_Rop op, Eina_Array *clips, unsigned int mul_col)
Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
{
Ector_Renderer_Generic_Gradient_Linear_Data *gld;
Ector_Renderer_Generic_Gradient_Data *gd;

2
src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
View File

@ -68,7 +68,7 @@ _ector_renderer_cairo_gradient_radial_prepare(Eo *obj EINA_UNUSED,
// Clearly duplicated and should be in a common place...
static Eina_Bool
_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd, Ector_Rop op, Eina_Array *clips, unsigned int mul_col)
_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
{
Ector_Renderer_Generic_Gradient_Radial_Data *grd;
Ector_Renderer_Generic_Gradient_Data *gd;

2
src/lib/ector/cairo/ector_renderer_cairo_shape.c
View File

@ -153,7 +153,7 @@ _ector_renderer_cairo_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_R
}
static Eina_Bool
_ector_renderer_cairo_shape_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd, Ector_Rop op, Eina_Array *clips, unsigned int mul_col)
_ector_renderer_cairo_shape_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
{
int r, g, b, a;
unsigned i;

18
src/lib/ector/ector_private.h
View File

@ -43,24 +43,6 @@ extern int _ector_log_dom_global;
typedef unsigned char DATA8;
typedef unsigned short DATA16;
#ifndef WORDS_BIGENDIAN
/* x86 */
#define A_VAL(p) (((DATA8 *)(p))[3])
#define R_VAL(p) (((DATA8 *)(p))[2])
#define G_VAL(p) (((DATA8 *)(p))[1])
#define B_VAL(p) (((DATA8 *)(p))[0])
#define AR_VAL(p) ((DATA16 *)(p)[1])
#define GB_VAL(p) ((DATA16 *)(p)[0])
#else
/* ppc */
#define A_VAL(p) (((DATA8 *)(p))[0])
#define R_VAL(p) (((DATA8 *)(p))[1])
#define G_VAL(p) (((DATA8 *)(p))[2])
#define B_VAL(p) (((DATA8 *)(p))[3])
#define AR_VAL(p) ((DATA16 *)(p)[0])
#define GB_VAL(p) ((DATA16 *)(p)[1])
#endif
#define RGB_JOIN(r,g,b) \
(((r) << 16) + ((g) << 8) + (b))

2
src/lib/ector/ector_renderer_generic_base.eo
View File

@ -105,7 +105,7 @@ abstract Ector.Renderer.Generic.Base (Eo.Base)
draw {
return: bool @warn_unused;
params {
@in op: Ector_Rop;
@in op: Efl.Gfx.Render_Op;
@in clips: array<Eina.Rectangle *> *; [[array of @Eina.Rectangle clip]]
@in mul_col: uint;
}

4
src/lib/ector/software/ector_renderer_software_gradient_linear.c
View File

@ -47,7 +47,7 @@ _ector_renderer_software_gradient_linear_ector_renderer_generic_base_prepare(Eo
static Eina_Bool
_ector_renderer_software_gradient_linear_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED,
Ector_Rop op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
unsigned int mul_col EINA_UNUSED)
{
return EINA_TRUE;
@ -57,7 +57,7 @@ static Eina_Bool
_ector_renderer_software_gradient_linear_ector_renderer_software_base_fill(Eo *obj EINA_UNUSED,
Ector_Renderer_Software_Gradient_Data *pd)
{
ector_software_rasterizer_linear_gradient_set(pd->surface->software, pd);
ector_software_rasterizer_linear_gradient_set(pd->surface->rasterizer, pd);
return EINA_TRUE;
}

4
src/lib/ector/software/ector_renderer_software_gradient_radial.c
View File

@ -58,7 +58,7 @@ _ector_renderer_software_gradient_radial_ector_renderer_generic_base_prepare(Eo
static Eina_Bool
_ector_renderer_software_gradient_radial_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED,
Ector_Rop op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
unsigned int mul_col EINA_UNUSED)
{
return EINA_TRUE;
@ -68,7 +68,7 @@ _ector_renderer_software_gradient_radial_ector_renderer_generic_base_draw(Eo *ob
static Eina_Bool
_ector_renderer_software_gradient_radial_ector_renderer_software_base_fill(Eo *obj EINA_UNUSED, Ector_Renderer_Software_Gradient_Data *pd)
{
ector_software_rasterizer_radial_gradient_set(pd->surface->software, pd);
ector_software_rasterizer_radial_gradient_set(pd->surface->rasterizer, pd);
return EINA_TRUE;
}

26
src/lib/ector/software/ector_renderer_software_shape.c
View File

@ -536,13 +536,13 @@ _update_rle(Eo *obj, Ector_Renderer_Software_Shape_Data *pd)
//shape data generation
if (_generate_shape_data(pd))
pd->shape_data = ector_software_rasterizer_generate_rle_data(pd->surface->software,
pd->shape_data = ector_software_rasterizer_generate_rle_data(pd->surface->rasterizer,
&outline->ft_outline);
//stroke data generation
if ( _generate_stroke_data(pd))
{
ector_software_rasterizer_stroke_set(pd->surface->software,
ector_software_rasterizer_stroke_set(pd->surface->rasterizer,
(pd->public_shape->stroke.width *
pd->public_shape->stroke.scale),
pd->public_shape->stroke.cap,
@ -555,14 +555,14 @@ _update_rle(Eo *obj, Ector_Renderer_Software_Shape_Data *pd)
pd->public_shape->stroke.dash,
pd->public_shape->stroke.dash_length);
_outline_transform(dash_outline, pd->base->m);
pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(pd->surface->software,
pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(pd->surface->rasterizer,
&dash_outline->ft_outline,
close_path);
_outline_destroy(dash_outline);
}
else
{
pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(pd->surface->software,
pd->outline_data = ector_software_rasterizer_generate_stroke_rle_data(pd->surface->rasterizer,
&outline->ft_outline,
close_path);
}
@ -593,7 +593,7 @@ _ector_renderer_software_shape_ector_renderer_generic_base_prepare(Eo *obj,
static Eina_Bool
_ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
Ector_Renderer_Software_Shape_Data *pd,
Ector_Rop op, Eina_Array *clips,
Efl_Gfx_Render_Op op, Eina_Array *clips,
unsigned int mul_col)
{
int x, y;
@ -606,13 +606,13 @@ _ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
y = pd->surface->y + (int)pd->base->origin.y;
// fill the span_data structure
ector_software_rasterizer_clip_rect_set(pd->surface->software, clips);
ector_software_rasterizer_transform_set(pd->surface->software, pd->base->m);
ector_software_rasterizer_clip_rect_set(pd->surface->rasterizer, clips);
ector_software_rasterizer_transform_set(pd->surface->rasterizer, pd->base->m);
if (pd->shape->fill)
{
eo_do(pd->shape->fill, ector_renderer_software_base_fill());
ector_software_rasterizer_draw_rle_data(pd->surface->software,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op,
pd->shape_data);
}
@ -620,12 +620,12 @@ _ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
{
if (pd->base->color.a > 0)
{
ector_software_rasterizer_color_set(pd->surface->software,
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->software,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op,
pd->shape_data);
}
@ -634,7 +634,7 @@ _ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
if (pd->shape->stroke.fill)
{
eo_do(pd->shape->stroke.fill, ector_renderer_software_base_fill());
ector_software_rasterizer_draw_rle_data(pd->surface->software,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op,
pd->outline_data);
}
@ -642,12 +642,12 @@ _ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
{
if (pd->public_shape->stroke.color.a > 0)
{
ector_software_rasterizer_color_set(pd->surface->software,
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->software,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op,
pd->outline_data);
}

1
src/lib/ector/software/ector_software_buffer.c
View File

@ -10,6 +10,7 @@
#include "ector_software_private.h"
#include "ector_generic_buffer.eo.h"
#include "ector_software_buffer_base.eo.h"
#include "draw.h"
#define MY_CLASS ECTOR_SOFTWARE_BUFFER_CLASS

35
src/lib/ector/software/ector_software_gradient.c
View File

@ -9,8 +9,7 @@
#include "ector_private.h"
#include "ector_software_private.h"
#include "ector_drawhelper_private.h"
#include "draw.h"
#define GRADIENT_STOPTABLE_SIZE 1024
#define FIXPT_BITS 8
@ -302,7 +301,7 @@ _generate_gradient_color_table(Efl_Gfx_Gradient_Stop *gradient_stops, int stop_c
curr = gradient_stops;
if (curr->a != 255) alpha = EINA_TRUE;
current_color = ECTOR_ARGB_JOIN(curr->a, curr->r, curr->g, curr->b);
current_color = DRAW_ARGB_JOIN(curr->a, curr->r, curr->g, curr->b);
incr = 1.0 / (double)size;
fpos = 1.5 * incr;
@ -323,7 +322,7 @@ _generate_gradient_color_table(Efl_Gfx_Gradient_Stop *gradient_stops, int stop_c
next = (gradient_stops + i + 1);
delta = 1/(next->offset - curr->offset);
if (next->a != 255) alpha = EINA_TRUE;
next_color = ECTOR_ARGB_JOIN(next->a, next->r, next->g, next->b);
next_color = DRAW_ARGB_JOIN(next->a, next->r, next->g, next->b);
func = &_ease_linear;
while (fpos < next->offset && pos < size)
{
@ -405,7 +404,7 @@ fetch_linear_gradient(uint *buffer, Span_Data *data, int y, int x, int length)
end = buffer + length;
if (inc > (float)(-1e-5) && inc < (float)(1e-5))
{
_ector_memfill(buffer, length, _gradient_pixel_fixed(g_data, (int)(t * FIXPT_SIZE)));
draw_memset32(buffer, _gradient_pixel_fixed(g_data, (int)(t * FIXPT_SIZE)), length);
}
else
{
@ -456,7 +455,7 @@ fetch_radial_gradient(uint *buffer, Span_Data *data, int y, int x, int length)
// avoid division by zero
if (fabsf(g_data->radial.a) <= 0.00001f)
{
_ector_memfill(buffer, length, 0);
draw_memset32(buffer, 0, length);
return;
}
@ -495,17 +494,21 @@ fetch_radial_gradient(uint *buffer, Span_Data *data, int y, int x, int length)
_ector_radial_helper(buffer, length, g_data, det, delta_det, delta_delta_det, b, delta_b);
}
void
drawhelper_gradient_init()
int
ector_software_gradient_init(void)
{
_ector_radial_helper = _radial_helper_generic;
_ector_linear_helper = _linear_helper_generic;
#ifdef BUILD_SSE3
if (eina_cpu_features_get() & EINA_CPU_SSE3)
static int i = 0;
if (!(i++))
{
_ector_radial_helper = _radial_helper_sse3;
_ector_linear_helper = _linear_helper_sse3;
}
_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;
}

7
src/lib/ector/software/ector_software_private.h
View File

@ -91,7 +91,7 @@ typedef struct _Span_Data
Span_Data_Type type;
Eina_Bool fast_matrix ;
DATA32 mul_col;
Ector_Rop op;
Efl_Gfx_Render_Op op;
union {
DATA32 color;
Ector_Renderer_Software_Gradient_Data *gradient;
@ -112,12 +112,13 @@ struct _Software_Rasterizer
struct _Ector_Software_Surface_Data
{
Software_Rasterizer *software;
Software_Rasterizer *rasterizer;
int x;
int y;
};
int ector_software_gradient_init(void);
void ector_software_rasterizer_init(Software_Rasterizer *rasterizer);
void ector_software_rasterizer_done(Software_Rasterizer *rasterizer);
@ -137,7 +138,7 @@ void ector_software_rasterizer_clip_shape_set(Software_Rasterizer *rasterizer, S
Shape_Rle_Data * ector_software_rasterizer_generate_rle_data(Software_Rasterizer *rasterizer, SW_FT_Outline *outline);
Shape_Rle_Data * ector_software_rasterizer_generate_stroke_rle_data(Software_Rasterizer *rasterizer, SW_FT_Outline *outline, Eina_Bool closePath);
void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, int x, int y, uint mul_col, Ector_Rop op, Shape_Rle_Data* rle);
void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, int x, int y, uint mul_col, Efl_Gfx_Render_Op op, Shape_Rle_Data* rle);
void ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle);

17
src/lib/ector/software/ector_software_rasterizer.c
View File

@ -9,7 +9,7 @@
#include "ector_private.h"
#include "ector_software_private.h"
#include "ector_drawhelper_private.h"
#include "draw.h"
static void
_blend_color_argb(int count, const SW_FT_Span *spans, void *user_data)
@ -20,8 +20,8 @@ _blend_color_argb(int count, const SW_FT_Span *spans, void *user_data)
const int pix_stride = data->raster_buffer->stride / 4;
// multiply the color with mul_col if any
color = ECTOR_MUL4_SYM(data->color, data->mul_col);
comp_func = ector_comp_func_solid_span_get(data->op, color);
color = DRAW_MUL4_SYM(data->color, data->mul_col);
comp_func = efl_draw_func_solid_span_get(data->op, color);
// move to the offset location
buffer = data->raster_buffer->pixels.u32 + ((pix_stride * data->offy) + data->offx);
@ -55,7 +55,7 @@ _blend_gradient(int count, const SW_FT_Span *spans, void *user_data)
if (!fetchfunc)
return;
comp_func = ector_comp_func_span_get(data->op, data->mul_col, data->gradient->alpha);
comp_func = efl_draw_func_span_get(data->op, data->mul_col, data->gradient->alpha);
// move to the offset location
destbuffer = data->raster_buffer->pixels.u32 + ((pix_stride * data->offy) + data->offx);
@ -102,7 +102,7 @@ _blend_image_argb(int count, const SW_FT_Span *spans, void *user_data)
#warning FIXME: Image scaling, anyone?
#warning FIXME: Optimize eo call with early call resolution
comp_func = ector_comp_func_span_get(data->op, data->mul_col, EINA_TRUE);
comp_func = efl_draw_func_span_get(data->op, data->mul_col, EINA_TRUE);
buffer = data->raster_buffer->pixels.u32 + ((pix_stride * data->offy) + data->offx);
@ -368,7 +368,8 @@ void ector_software_rasterizer_init(Software_Rasterizer *rasterizer)
rasterizer->fill_data.clip.enabled = EINA_FALSE;
rasterizer->fill_data.unclipped_blend = 0;
rasterizer->fill_data.blend = 0;
draw_helper_init();
efl_draw_init();
ector_software_gradient_init();
}
void ector_software_rasterizer_done(Software_Rasterizer *rasterizer)
@ -551,7 +552,7 @@ void ector_software_rasterizer_clip_shape_set(Software_Rasterizer *rasterizer, S
void ector_software_rasterizer_color_set(Software_Rasterizer *rasterizer, int r, int g, int b, int a)
{
rasterizer->fill_data.color = ECTOR_ARGB_JOIN(a, r, g, b);
rasterizer->fill_data.color = DRAW_ARGB_JOIN(a, r, g, b);
rasterizer->fill_data.type = Solid;
}
@ -578,7 +579,7 @@ void ector_software_rasterizer_buffer_set(Software_Rasterizer *rasterizer,
void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
int x, int y, uint mul_col,
Ector_Rop op, Shape_Rle_Data* rle)
Efl_Gfx_Render_Op op, Shape_Rle_Data* rle)
{
// check for NULL rle data
if (!rle) return;

14
src/lib/ector/software/ector_software_surface.c
View File

@ -35,19 +35,19 @@ static Eo *
_ector_software_surface_eo_base_constructor(Eo *obj, Ector_Software_Surface_Data *pd)
{
obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
pd->software = (Software_Rasterizer *) calloc(1, sizeof(Software_Rasterizer));
ector_software_rasterizer_init(pd->software);
pd->software->fill_data.raster_buffer = eo_data_ref(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
pd->rasterizer = (Software_Rasterizer *) calloc(1, sizeof(Software_Rasterizer));
ector_software_rasterizer_init(pd->rasterizer);
pd->rasterizer->fill_data.raster_buffer = eo_data_ref(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
return obj;
}
static void
_ector_software_surface_eo_base_destructor(Eo *obj, Ector_Software_Surface_Data *pd)
{
ector_software_rasterizer_done(pd->software);
eo_data_unref(obj, pd->software->fill_data.raster_buffer);
free(pd->software);
pd->software = NULL;
ector_software_rasterizer_done(pd->rasterizer);
eo_data_unref(obj, pd->rasterizer->fill_data.raster_buffer);
free(pd->rasterizer);
pd->rasterizer = NULL;
eo_do_super(obj, ECTOR_SOFTWARE_SURFACE_CLASS, eo_destructor());
}

1
src/lib/efl/Efl.h
View File

@ -196,6 +196,7 @@ EAPI extern const Eo_Event_Description _EFL_GFX_PATH_CHANGED;
#ifndef EFL_NOLEGACY_API_SUPPORT
#include "interfaces/efl_gfx_fill.eo.legacy.h"
#include "interfaces/efl_gfx_base.eo.legacy.h"
#endif
#endif

6
src/lib/efl/interfaces/efl_gfx_base.eo
View File

@ -3,6 +3,12 @@ enum Efl.Gfx.Colorspace {
gry8 = 4, [[8-bit gray image, or alpha only]]
}
enum Efl.Gfx.Render_Op {
blend = 0, [[Alpha blending onto destination (default); d = d*(1-sa) + s]]
copy = 1, [[Copy source to destination; d = s]]
last
}
interface Efl.Gfx.Base {
legacy_prefix: null;
eo_prefix: efl_gfx;

3
src/lib/evas/include/evas_common_private.h
View File

@ -55,7 +55,6 @@
# include <Eet.h>
#endif
#include "Evas.h"
//#include "Evas_GL.h"
#ifdef EAPI
# undef EAPI
@ -1159,6 +1158,7 @@ struct _Convert_Pal
/*****************************************************************************/
#include "evas_macros.h"
#ifndef A_VAL
#ifndef WORDS_BIGENDIAN
/* x86 */
#define A_VAL(p) (((DATA8 *)(p))[3])
@ -1176,6 +1176,7 @@ struct _Convert_Pal
#define AR_VAL(p) ((DATA16 *)(p)[0])
#define GB_VAL(p) ((DATA16 *)(p)[1])
#endif
#endif
#define RGB_JOIN(r,g,b) \
(((r) << 16) + ((g) << 8) + (b))

8
src/modules/evas/engines/gl_generic/evas_engine.c
View File

@ -2452,17 +2452,17 @@ eng_ector_destroy(void *data EINA_UNUSED, Ector_Surface *ector)
if (ector) eo_del(ector);
}
static Ector_Rop
static Efl_Gfx_Render_Op
_evas_render_op_to_ector_rop(Evas_Render_Op op)
{
switch (op)
{
case EVAS_RENDER_BLEND:
return ECTOR_ROP_BLEND;
return EFL_GFX_RENDER_OP_BLEND;
case EVAS_RENDER_COPY:
return ECTOR_ROP_COPY;
return EFL_GFX_RENDER_OP_COPY;
default:
return ECTOR_ROP_BLEND;
return EFL_GFX_RENDER_OP_BLEND;
}
}

10
src/modules/evas/engines/software_generic/evas_engine.c
View File

@ -398,7 +398,7 @@ struct _Evas_Thread_Command_Ector
Eina_Array *clips;
DATA32 mul_col;
Ector_Rop render_op;
Efl_Gfx_Render_Op render_op;
Eina_Bool free_it;
};
@ -3754,17 +3754,17 @@ eng_ector_destroy(void *data EINA_UNUSED, Ector_Surface *ector)
if (ector) eo_del(ector);
}
static Ector_Rop
static Efl_Gfx_Render_Op
_evas_render_op_to_ector_rop(Evas_Render_Op op)
{
switch (op)
{
case EVAS_RENDER_BLEND:
return ECTOR_ROP_BLEND;
return EFL_GFX_RENDER_OP_BLEND;
case EVAS_RENDER_COPY:
return ECTOR_ROP_COPY;
return EFL_GFX_RENDER_OP_COPY;
default:
return ECTOR_ROP_BLEND;
return EFL_GFX_RENDER_OP_BLEND;
}
}

112
src/lib/ector/software/ector_drawhelper_private.h → src/static_libs/draw/draw.h
View File

@ -1,7 +1,22 @@
#ifndef ECTOR_DRAWHELPER_PRIVATE_H
#define ECTOR_DRAWHELPER_PRIVATE_H
#ifndef EFL_DRAW_H
#define EFL_DRAW_H
#include "ector_private.h"
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <Efl.h>
typedef void (*RGBA_Comp_Func)(uint *dest, const uint *src, int length, uint mul_col, uint const_alpha);
typedef void (*RGBA_Comp_Func_Solid)(uint *dest, int length, uint color, uint const_alpha);
int efl_draw_init(void);
RGBA_Comp_Func_Solid efl_draw_func_solid_span_get(Efl_Gfx_Render_Op op, uint color);
RGBA_Comp_Func efl_draw_func_span_get(Efl_Gfx_Render_Op op, uint color, Eina_Bool src_alpha);
/* common sw draw helpers */
#ifndef MIN
#define MIN( a, b ) ( (a) < (b) ? (a) : (b) )
@ -11,53 +26,53 @@
#define MAX( a, b ) ( (a) > (b) ? (a) : (b) )
#endif
#ifndef uint
typedef unsigned int uint;
#ifndef A_VAL
#ifndef WORDS_BIGENDIAN
/* x86 */
#define A_VAL(p) (((uint8_t *)(p))[3])
#define R_VAL(p) (((uint8_t *)(p))[2])
#define G_VAL(p) (((uint8_t *)(p))[1])
#define B_VAL(p) (((uint8_t *)(p))[0])
#define AR_VAL(p) ((uint16_t *)(p)[1])
#define GB_VAL(p) ((uint16_t *)(p)[0])
#else
/* ppc */
#define A_VAL(p) (((uint8_t *)(p))[0])
#define R_VAL(p) (((uint8_t *)(p))[1])
#define G_VAL(p) (((uint8_t *)(p))[2])
#define B_VAL(p) (((uint8_t *)(p))[3])
#define AR_VAL(p) ((uint16_t *)(p)[0])
#define GB_VAL(p) ((uint16_t *)(p)[1])
#endif
#endif
#define ECTOR_ARGB_JOIN(a,r,g,b) \
#define DRAW_ARGB_JOIN(a,r,g,b) \
(((a) << 24) + ((r) << 16) + ((g) << 8) + (b))
#define ECTOR_MUL4_SYM(x, y) \
#define DRAW_MUL4_SYM(x, y) \
( ((((((x) >> 16) & 0xff00) * (((y) >> 16) & 0xff00)) + 0xff0000) & 0xff000000) + \
((((((x) >> 8) & 0xff00) * (((y) >> 16) & 0xff)) + 0xff00) & 0xff0000) + \
((((((x) & 0xff00) * ((y) & 0xff00)) + 0xff0000) >> 16) & 0xff00) + \
(((((x) & 0xff) * ((y) & 0xff)) + 0xff) >> 8) )
#define BYTE_MUL(c, a) \
( (((((c) >> 8) & 0x00ff00ff) * (a)) & 0xff00ff00) + \
(((((c) & 0x00ff00ff) * (a)) >> 8) & 0x00ff00ff) )
#define LOOP_ALIGNED_U1_A4(DEST, LENGTH, UOP, A4OP) \
{ \
while((uintptr_t)DEST & 0xF && LENGTH) UOP \
\
while(LENGTH) { \
switch(LENGTH) { \
case 3: \
case 2: \
case 1: \
UOP \
break; \
default: \
A4OP \
break; \
} \
} \
}
static inline int
alpha_inverse(int color)
static inline uint
INTERPOLATE_PIXEL_256(uint x, uint a, uint y, uint b)
{
color = ~color;
return A_VAL(&color);
uint t = (x & 0xff00ff) * a + (y & 0xff00ff) * b;
t >>= 8;
t &= 0xff00ff;
x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b;
x &= 0xff00ff00;
x |= t;
return x;
}
static inline void
_ector_memfill(uint *dest, int length, uint value)
draw_memset32(uint *dest, uint value, int length)
{
int n;
if (!length)
if (length <= 0)
return;
n = (length + 7) / 8;
@ -75,31 +90,4 @@ _ector_memfill(uint *dest, int length, uint value)
}
}
static inline uint
INTERPOLATE_PIXEL_256(uint x, uint a, uint y, uint b)
{
uint t = (x & 0xff00ff) * a + (y & 0xff00ff) * b;
t >>= 8;
t &= 0xff00ff;
x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b;
x &= 0xff00ff00;
x |= t;
return x;
}
typedef void (*RGBA_Comp_Func)(uint *dest, const uint *src, int length, uint mul_col, uint const_alpha);
typedef void (*RGBA_Comp_Func_Solid)(uint *dest, int length, uint color, uint const_alpha);
extern RGBA_Comp_Func_Solid func_for_mode_solid[ECTOR_ROP_LAST];
extern RGBA_Comp_Func func_for_mode[ECTOR_ROP_LAST];
void drawhelper_gradient_init(void);
void draw_helper_sse2_init(void);
void draw_helper_neon_init(void);
void draw_helper_init(void);
RGBA_Comp_Func_Solid ector_comp_func_solid_span_get(Ector_Rop op, uint color);
RGBA_Comp_Func ector_comp_func_span_get(Ector_Rop op, uint color, Eina_Bool src_alpha);
#endif

49
src/lib/ector/software/ector_drawhelper.c → src/static_libs/draw/draw_main.c
View File

@ -3,7 +3,7 @@
#endif
#include <Ector.h>
#include "ector_drawhelper_private.h"
#include "draw_private.h"
/*
s = source pixel
@ -27,10 +27,10 @@ _comp_func_solid_source_over(uint *dest, int length, uint color, uint const_alph
int ialpha, i;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
ialpha = alpha_inverse(color);
for (i = 0; i < length; ++i)
dest[i] = color + BYTE_MUL(dest[i], ialpha);
dest[i] = color + DRAW_BYTE_MUL(dest[i], ialpha);
}
static void
@ -40,7 +40,7 @@ _comp_func_source_over(uint *dest, const uint *src, int length, uint color, uint
uint s, sc, sia;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
if (color == 0xffffffff) // No color multiplier
{
@ -52,7 +52,7 @@ _comp_func_source_over(uint *dest, const uint *src, int length, uint color, uint
else if (s != 0)
{
sia = alpha_inverse(s);
dest[i] = s + BYTE_MUL(dest[i], sia);
dest[i] = s + DRAW_BYTE_MUL(dest[i], sia);
}
}
}
@ -61,9 +61,9 @@ _comp_func_source_over(uint *dest, const uint *src, int length, uint color, uint
for (i = 0; i < length; ++i)
{
s = src[i];
sc = ECTOR_MUL4_SYM(color, s);
sc = DRAW_MUL4_SYM(color, s);
sia = alpha_inverse(sc);
dest[i] = sc + BYTE_MUL(dest[i], sia);
dest[i] = sc + DRAW_BYTE_MUL(dest[i], sia);
}
}
}
@ -79,14 +79,14 @@ _comp_func_solid_source(uint *dest, int length, uint color, uint const_alpha)
if (const_alpha == 255)
{
_ector_memfill(dest, length, color);
draw_memset32(dest, color, length);
}
else
{
ialpha = 255 - const_alpha;
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
for (i = 0; i < length; ++i)
dest[i] = color + BYTE_MUL(dest[i], ialpha);
dest[i] = color + DRAW_BYTE_MUL(dest[i], ialpha);
}
}
@ -114,54 +114,59 @@ _comp_func_source(uint *dest, const uint *src, int length, uint color, uint cons
if (const_alpha == 255)
{
for (i = 0; i < length; ++i)
dest[i] = ECTOR_MUL4_SYM(src[i], color);
dest[i] = DRAW_MUL4_SYM(src[i], color);
}
else
{
ialpha = 255 - const_alpha;
for (i = 0; i < length; ++i)
{
src_color = ECTOR_MUL4_SYM(src[i], color);
src_color = DRAW_MUL4_SYM(src[i], color);
dest[i] = INTERPOLATE_PIXEL_256(src_color, const_alpha, dest[i], ialpha);
}
}
}
}
RGBA_Comp_Func_Solid func_for_mode_solid[ECTOR_ROP_LAST] = {
RGBA_Comp_Func_Solid func_for_mode_solid[EFL_GFX_RENDER_OP_LAST] = {
_comp_func_solid_source_over,
_comp_func_solid_source
};
RGBA_Comp_Func func_for_mode[ECTOR_ROP_LAST] = {
RGBA_Comp_Func func_for_mode[EFL_GFX_RENDER_OP_LAST] = {
_comp_func_source_over,
_comp_func_source
};
RGBA_Comp_Func_Solid
ector_comp_func_solid_span_get(Ector_Rop op, uint color)
efl_draw_func_solid_span_get(Efl_Gfx_Render_Op op, uint color)
{
if ((color & 0xff000000) == 0xff000000)
{
if (op == ECTOR_ROP_BLEND) op = ECTOR_ROP_COPY;
if (op == EFL_GFX_RENDER_OP_BLEND) op = EFL_GFX_RENDER_OP_COPY;
}
return func_for_mode_solid[op];
}
RGBA_Comp_Func ector_comp_func_span_get(Ector_Rop op, uint color, Eina_Bool src_alpha)
RGBA_Comp_Func efl_draw_func_span_get(Efl_Gfx_Render_Op op, uint color, Eina_Bool src_alpha)
{
if (((color & 0xff000000) == 0xff000000) && !src_alpha)
{
if (op == ECTOR_ROP_BLEND) op = ECTOR_ROP_COPY;
if (op == EFL_GFX_RENDER_OP_BLEND) op = EFL_GFX_RENDER_OP_COPY;
}
return func_for_mode[op];
}
void draw_helper_init()
int
efl_draw_init()
{
drawhelper_gradient_init();
draw_helper_sse2_init();
draw_helper_neon_init();
static int i = 0;
if (!(i++))
{
efl_draw_sse2_init();
efl_draw_neon_init();
}
return i;
}

17
src/lib/ector/software/ector_drawhelper_neon.c → src/static_libs/draw/draw_main_neon.c
View File

@ -2,8 +2,7 @@
#include "config.h"
#endif
#include <Ector.h>
#include "ector_drawhelper_private.h"
#include "draw_private.h"
#undef BUILD_NEON
#ifdef BUILD_NEON
@ -36,7 +35,7 @@ comp_func_solid_source_over_neon(uint * __restrict dest, int length, uint color,
uint8x8_t temp11_8x8;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
// alpha can only be 0 if color is 0x0. In that case we can just return.
// Otherwise we can assume alpha != 0. This allows more optimization in
@ -140,7 +139,7 @@ comp_func_source_over_sse2(uint * __restrict dest, const uint * __restrict src,
DATA32 *end;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
c_32x2 = vdup_n_u32(color);
c_8x8 = vreinterpret_u8_u32(c_32x2);
@ -215,18 +214,18 @@ comp_func_source_over_sse2(uint * __restrict dest, const uint * __restrict src,
#endif
void
draw_helper_neon_init()
efl_draw_neon_init()
{
#ifdef BUILD_NEON
if (eina_cpu_features_get() & EINA_CPU_NEON)
{
// update the comp_function table for solid color
//func_for_mode_solid[ECTOR_ROP_COPY] = comp_func_solid_source_sse2;
func_for_mode_solid[ECTOR_ROP_BLEND] = comp_func_solid_source_over_neon;
//func_for_mode_solid[EFL_GFX_RENDER_OP_COPY] = comp_func_solid_source_sse2;
func_for_mode_solid[EFL_GFX_RENDER_OP_BLEND] = comp_func_solid_source_over_neon;
// update the comp_function table for source data
//func_for_mode[ECTOR_ROP_COPY] = comp_func_source_sse2;
func_for_mode[ECTOR_ROP_BLEND] = comp_func_source_over_neon;
//func_for_mode[EFL_GFX_RENDER_OP_COPY] = comp_func_source_sse2;
func_for_mode[EFL_GFX_RENDER_OP_BLEND] = comp_func_source_over_neon;
}
#endif
}

32
src/lib/ector/software/ector_drawhelper_sse2.c → src/static_libs/draw/draw_main_sse2.c
View File

@ -3,7 +3,7 @@
#endif
#include <Ector.h>
#include "ector_drawhelper_private.h"
#include "draw_private.h"
#ifdef BUILD_SSE3
#include <immintrin.h>
@ -125,7 +125,7 @@ comp_func_helper_sse2 (uint *dest, int length, uint color, uint alpha)
LOOP_ALIGNED_U1_A4(dest, length,
{ /* UOP */
*dest = color + BYTE_MUL(*dest, alpha);
*dest = color + DRAW_BYTE_MUL(*dest, alpha);
dest++; length--;
},
{ /* A4OP */
@ -145,14 +145,14 @@ comp_func_solid_source_sse2(uint *dest, int length, uint color, uint const_alpha
{
if (const_alpha == 255)
{
_ector_memfill(dest, length, color);
draw_memset32(dest, color, length);
}
else
{
int ialpha;
ialpha = 255 - const_alpha;
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
comp_func_helper_sse2(dest, length, color, ialpha);
}
}
@ -163,7 +163,7 @@ comp_func_solid_source_over_sse2(uint *dest, int length, uint color, uint const_
int ialpha;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
ialpha = alpha_inverse(color);
comp_func_helper_sse2(dest, length, color, ialpha);
}
@ -239,7 +239,7 @@ comp_func_source_sse2(uint *dest, const uint *src, int length, uint color, uint
{
LOOP_ALIGNED_U1_A4(dest, length,
{ /* UOP */
*dest = ECTOR_MUL4_SYM(*src, color);
*dest = DRAW_MUL4_SYM(*src, color);
dest++; src++; length--;
},
{ /* A4OP */
@ -256,7 +256,7 @@ comp_func_source_sse2(uint *dest, const uint *src, int length, uint color, uint
LOOP_ALIGNED_U1_A4(dest, length,
{ /* UOP */
src_color = ECTOR_MUL4_SYM(*src, color);
src_color = DRAW_MUL4_SYM(*src, color);
*dest = INTERPOLATE_PIXEL_256(src_color, const_alpha, *dest, ialpha);
dest++; src++; length--;
},
@ -277,7 +277,7 @@ comp_func_source_over_sse2(uint *dest, const uint *src, int length, uint color,
uint s, sia;
if (const_alpha != 255)
color = BYTE_MUL(color, const_alpha);
color = DRAW_BYTE_MUL(color, const_alpha);
if (color == 0xffffffff) // No color multiplier
{
@ -285,7 +285,7 @@ comp_func_source_over_sse2(uint *dest, const uint *src, int length, uint color,
{ /* UOP */
s = *src;
sia = alpha_inverse(s);
*dest = s + BYTE_MUL(*dest, sia);
*dest = s + DRAW_BYTE_MUL(*dest, sia);
dest++; src++; length--;
},
{ /* A4OP */
@ -301,9 +301,9 @@ comp_func_source_over_sse2(uint *dest, const uint *src, int length, uint color,
LOOP_ALIGNED_U1_A4(dest, length,
{ /* UOP */
s = ECTOR_MUL4_SYM(*src, color);
s = DRAW_MUL4_SYM(*src, color);
sia = alpha_inverse(s);
*dest = s + BYTE_MUL(*dest, sia);
*dest = s + DRAW_BYTE_MUL(*dest, sia);
dest++; src++; length--;
},
{ /* A4OP */
@ -319,18 +319,18 @@ comp_func_source_over_sse2(uint *dest, const uint *src, int length, uint color,
#endif
void
draw_helper_sse2_init()
efl_draw_sse2_init()
{
#ifdef BUILD_SSE3
if (eina_cpu_features_get() & EINA_CPU_SSE2)
{
// update the comp_function table for solid color
func_for_mode_solid[ECTOR_ROP_COPY] = comp_func_solid_source_sse2;
func_for_mode_solid[ECTOR_ROP_BLEND] = comp_func_solid_source_over_sse2;
func_for_mode_solid[EFL_GFX_RENDER_OP_COPY] = comp_func_solid_source_sse2;
func_for_mode_solid[EFL_GFX_RENDER_OP_BLEND] = comp_func_solid_source_over_sse2;
// update the comp_function table for source data
func_for_mode[ECTOR_ROP_COPY] = comp_func_source_sse2;
func_for_mode[ECTOR_ROP_BLEND] = comp_func_source_over_sse2;
func_for_mode[EFL_GFX_RENDER_OP_COPY] = comp_func_source_sse2;
func_for_mode[EFL_GFX_RENDER_OP_BLEND] = comp_func_source_over_sse2;
}
#endif
}

41
src/static_libs/draw/draw_private.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef EFL_DRAW_PRIVATE_H
#define EFL_DRAW_PRIVATE_H
#include "draw.h"
#define DRAW_BYTE_MUL(c, a) \
( (((((c) >> 8) & 0x00ff00ff) * (a)) & 0xff00ff00) + \
(((((c) & 0x00ff00ff) * (a)) >> 8) & 0x00ff00ff) )
#define LOOP_ALIGNED_U1_A4(DEST, LENGTH, UOP, A4OP) \
{ \
while((uintptr_t)DEST & 0xF && LENGTH) UOP \
\
while(LENGTH) { \
switch(LENGTH) { \
case 3: \
case 2: \
case 1: \
UOP \
break; \
default: \
A4OP \
break; \
} \
} \
}
static inline int
alpha_inverse(uint32_t color)
{
color = ~color;
return A_VAL(&color);
}
RGBA_Comp_Func_Solid func_for_mode_solid[EFL_GFX_RENDER_OP_LAST];
RGBA_Comp_Func func_for_mode[EFL_GFX_RENDER_OP_LAST];
void efl_draw_sse2_init(void);
void efl_draw_neon_init(void);
#endif