cedric pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=2766ce57ce698850e50ebd8b92c4897fa739baf9
commit 2766ce57ce698850e50ebd8b92c4897fa739baf9 Author: Subhransu Mohanty <sub.moha...@samsung.com> Date: Mon Aug 17 15:18:26 2015 +0900 ector: refactored software drawing backend to use composition function. Signed-off-by: Cedric BAIL <ced...@osg.samsung.com> --- src/Makefile_Ector.am | 5 +- src/lib/ector/software/ector_drawhelper.c | 155 ++++++++ src/lib/ector/software/ector_drawhelper_private.h | 102 ++++++ src/lib/ector/software/ector_software_rasterizer.c | 403 ++++++++++----------- 4 files changed, 461 insertions(+), 204 deletions(-) diff --git a/src/Makefile_Ector.am b/src/Makefile_Ector.am index 6d99092..c05642f 100644 --- a/src/Makefile_Ector.am +++ b/src/Makefile_Ector.am @@ -95,7 +95,8 @@ lib/ector/software/ector_software_rasterizer.c \ lib/ector/software/ector_software_surface.c \ lib/ector/software/sw_ft_math.c \ lib/ector/software/sw_ft_raster.c \ -lib/ector/software/sw_ft_stroker.c +lib/ector/software/sw_ft_stroker.c \ +lib/ector/software/ector_drawhelper.c installed_ectorsoftwareheadersdir = $(includedir)/ector-@VMAJ@/software nodist_installed_ectorsoftwareheaders_DATA = $(ector_eolian_software_h) @@ -147,7 +148,7 @@ endif EXTRA_DIST += \ lib/ector/ector_private.h \ lib/ector/cairo/ector_cairo_private.h \ -lib/ector/software/ector_blend_private.h \ +lib/ector/software/ector_drawhelper_private.h \ lib/ector/software/ector_software_private.h \ lib/ector/software/sw_ft_math.h \ lib/ector/software/sw_ft_raster.h \ diff --git a/src/lib/ector/software/ector_drawhelper.c b/src/lib/ector/software/ector_drawhelper.c new file mode 100644 index 0000000..40e7faa --- /dev/null +++ b/src/lib/ector/software/ector_drawhelper.c @@ -0,0 +1,155 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <Ector.h> +#include "ector_drawhelper_private.h" + +/* + s = source pixel + d = destination pixel + ca = const_alpha + sia = source inverse alpha + cia = const inverse alpha + +*/ + +/* + result = s + d * sia + dest = (s + d * sia) * ca + d * cia + = s * ca + d * (sia * ca + cia) + = s * ca + d * (1 - sa*ca) +*/ +void +comp_func_solid_source_over(uint *dest, int length, uint color, uint const_alpha) +{ + int ialpha, i; + if (const_alpha != 255) + color = BYTE_MUL(color, const_alpha); + ialpha = Alpha(~color); + for (i = 0; i < length; ++i) + dest[i] = color + BYTE_MUL(dest[i], ialpha); +} + + +static void +comp_func_source_over(uint *dest, const uint *src, int length, uint color, uint const_alpha) +{ + int i; + uint s, sc, sia; + if (const_alpha != 255) + color = BYTE_MUL(color, const_alpha); + + if (color == 0xffffffff) // No color multiplier + { + for (i = 0; i < length; ++i) + { + s = src[i]; + if (s >= 0xff000000) + dest[i] = s; + else if (s != 0) + { + sia = Alpha(~s); + dest[i] = s + BYTE_MUL(dest[i], sia); + } + } + } + else + { + for (i = 0; i < length; ++i) + { + s = src[i]; + sc = ECTOR_MUL4_SYM(color, s); + sia = Alpha(~sc); + dest[i] = sc + BYTE_MUL(dest[i], sia); + } + } +} + +/* + result = s + dest = s * ca + d * cia +*/ +static void +comp_func_solid_source(uint *dest, int length, uint color, uint const_alpha) +{ + int ialpha, i; + if (const_alpha == 255) _ector_memfill(dest, length, color); + else + { + ialpha = 255 - const_alpha; + color = BYTE_MUL(color, const_alpha); + for (i = 0; i < length; ++i) + dest[i] = color + BYTE_MUL(dest[i], ialpha); + } +} + +static void +comp_func_source(uint *dest, const uint *src, int length, uint color, uint const_alpha) +{ + int i, ialpha; + uint src_color; + if (color == 0xffffffff) // No color multiplier + { + if (const_alpha == 255) + memcpy(dest, src, length * sizeof(uint)); + else + { + ialpha = 255 - const_alpha; + for (i = 0; i < length; ++i) + dest[i] = INTERPOLATE_PIXEL_256(src[i], const_alpha, dest[i], ialpha); + } + } + else + { + if (const_alpha == 255) + { + for (i = 0; i < length; ++i) + dest[i] = ECTOR_MUL4_SYM(src[i], color); + } + else + { + ialpha = 255 - const_alpha; + for (i = 0; i < length; ++i) + { + src_color = ECTOR_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] = { + comp_func_solid_source_over, + comp_func_solid_source +}; + +RGBA_Comp_Func func_for_mode[ECTOR_ROP_LAST] = { + comp_func_source_over, + comp_func_source +}; + +RGBA_Comp_Func_Solid +ector_comp_func_solid_span_get(Ector_Rop op, uint color) +{ + if ((color & 0xff000000) == 0xff000000) + { + if (op == ECTOR_ROP_BLEND) op = ECTOR_ROP_COPY; + } + + return func_for_mode_solid[op]; +} + +RGBA_Comp_Func ector_comp_func_span_get(Ector_Rop op, uint color, Eina_Bool src_alpha) +{ + if (((color & 0xff000000) == 0xff000000) && !src_alpha) + { + if (op == ECTOR_ROP_BLEND) op = ECTOR_ROP_COPY; + } + return func_for_mode[op]; +} + +void init_draw_helper() +{ + +} diff --git a/src/lib/ector/software/ector_drawhelper_private.h b/src/lib/ector/software/ector_drawhelper_private.h new file mode 100644 index 0000000..ea77760 --- /dev/null +++ b/src/lib/ector/software/ector_drawhelper_private.h @@ -0,0 +1,102 @@ +#ifndef ECTOR_DRAWHELPER_PRIVATE_H +#define ECTOR_DRAWHELPER_PRIVATE_H + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#ifndef MIN +#define MIN( a, b ) ( (a) < (b) ? (a) : (b) ) +#endif + +#ifndef MAX +#define MAX( a, b ) ( (a) > (b) ? (a) : (b) ) +#endif + +#ifndef uint +typedef unsigned int uint; +#endif + +inline int Alpha(uint c) +{ + return c>>24; +} + + + +#define ECTOR_ARGB_JOIN(a,r,g,b) \ + (((a) << 24) + ((r) << 16) + ((g) << 8) + (b)) + +#define ECTOR_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 void +_ector_memfill(uint *dest, int length, uint value) +{ + int n; + if (!length) + return; + + n = (length + 7) / 8; + switch (length & 0x07) + { + case 0: do { *dest++ = value; + case 7: *dest++ = value; + case 6: *dest++ = value; + case 5: *dest++ = value; + case 4: *dest++ = value; + case 3: *dest++ = value; + case 2: *dest++ = value; + case 1: *dest++ = value; + } while (--n > 0); + } +} + +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 init_draw_helper(); + +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 \ No newline at end of file diff --git a/src/lib/ector/software/ector_software_rasterizer.c b/src/lib/ector/software/ector_software_rasterizer.c index 5afb1ca..b436eed 100644 --- a/src/lib/ector/software/ector_software_rasterizer.c +++ b/src/lib/ector/software/ector_software_rasterizer.c @@ -8,49 +8,27 @@ #include "ector_private.h" #include "ector_software_private.h" -#include "ector_blend_private.h" + +#include "ector_drawhelper_private.h" static void _blend_color_argb(int count, const SW_FT_Span *spans, void *user_data) { + RGBA_Comp_Func_Solid comp_func; Span_Data *data = (Span_Data *)(user_data); + uint color, *buffer, *target; // multiply the color with mul_col if any - uint color = ECTOR_MUL4_SYM(data->color, data->mul_col); - Eina_Bool solid_source = ((color >> 24) == 255); + color = ECTOR_MUL4_SYM(data->color, data->mul_col); + comp_func = ector_comp_func_solid_span_get(data->op, color); // move to the offset location - uint *buffer = data->raster_buffer.buffer + (data->raster_buffer.width * data->offy + data->offx); - - if (solid_source) - { - while (count--) - { - uint *target = buffer + (data->raster_buffer.width * spans->y + spans->x); - if (spans->coverage == 255) - { - _ector_memfill(target, color, spans->len); - } - else - { - uint c = ECTOR_MUL_256(color, spans->coverage); - int ialpha = 255 - spans->coverage; - for (int i = 0; i < spans->len; ++i) - target[i] = c + ECTOR_MUL_256(target[i], ialpha); - } - ++spans; - } - return; - } + buffer = data->raster_buffer.buffer + ((data->raster_buffer.width * data->offy) + data->offx); while (count--) { - uint *target = buffer + (data->raster_buffer.width * spans->y + spans->x); - uint c = ECTOR_MUL_256(color, spans->coverage); - int ialpha = (~c) >> 24; - - for (int i = 0; i < spans->len; ++i) - target[i] = c + ECTOR_MUL_256(target[i], ialpha); + target = buffer + ((data->raster_buffer.width * spans->y) + spans->x); + comp_func(target, spans->len, color, spans->coverage); ++spans; } } @@ -62,37 +40,35 @@ typedef void (*src_fetch) (unsigned int *buffer, Span_Data *data, int y, int x, static void _blend_gradient(int count, const SW_FT_Span *spans, void *user_data) { - Span_Data *data = (Span_Data *)(user_data); - src_fetch fetchfunc = NULL; - - if(data->type == LinearGradient) fetchfunc = &fetch_linear_gradient; - if(data->type == RadialGradient) fetchfunc = &fetch_radial_gradient; - - unsigned int buffer[BLEND_GRADIENT_BUFFER_SIZE]; - - // move to the offset location - unsigned int *destbuffer = data->raster_buffer.buffer + (data->raster_buffer.width * data->offy + data->offx); - - while (count--) - { - unsigned int *target = destbuffer + (data->raster_buffer.width * spans->y + spans->x); - int length = spans->len; - while (length) - { - int l = MIN(length, BLEND_GRADIENT_BUFFER_SIZE); - if (fetchfunc) - fetchfunc(buffer, data, spans->y, spans->x, l); - else - memset(buffer, 0, sizeof(buffer)); - if (data->mul_col == 0xffffffff) - _ector_comp_func_source_over(target, buffer, l, spans->coverage); // TODO use proper composition func - else - _ector_comp_func_source_over_mul_c(target, buffer, data->mul_col, l, spans->coverage); - target += l; - length -= l; - } - ++spans; - } + RGBA_Comp_Func comp_func; + Span_Data *data = (Span_Data *)(user_data); + src_fetch fetchfunc = NULL; + unsigned int buffer[BLEND_GRADIENT_BUFFER_SIZE], *target, *destbuffer; + int length, l; + + //@TODO, Get the proper composition function using ,color, ECTOR_OP etc. + if (data->type == LinearGradient) fetchfunc = &fetch_linear_gradient; + if (data->type == RadialGradient) fetchfunc = &fetch_radial_gradient; + + comp_func = ector_comp_func_span_get(data->op, data->mul_col, data->gradient->alpha); + + // move to the offset location + destbuffer = data->raster_buffer.buffer + ((data->raster_buffer.width * data->offy) + data->offx); + + while (count--) + { + target = destbuffer + ((data->raster_buffer.width * spans->y) + spans->x); + length = spans->len; + while (length) + { + l = MIN(length, BLEND_GRADIENT_BUFFER_SIZE); + fetchfunc(buffer, data, spans->y, spans->x, l); + comp_func(target, buffer, l, data->mul_col, spans->coverage); + target += l; + length -= l; + } + ++spans; + } } @@ -101,14 +77,18 @@ _blend_gradient(int count, const SW_FT_Span *spans, void *user_data) 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 *_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; - const short minx = clip->x; - const short miny = clip->y; - const short maxx = minx + clip->w - 1; - const short maxy = miny + clip->h - 1; + 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 ) { @@ -140,129 +120,144 @@ SW_FT_Span *_intersect_spans_rect(const Eina_Rectangle *clip, const SW_FT_Span * out->coverage = spans->coverage; ++out; } - ++spans; --available; - } - - *out_spans = out; + } - return spans; + *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 *_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; - - 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; - } + 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; - int sx1 = spans->x; - int sx2 = sx1 + spans->len; - int cx1 = clipSpans->x; - int cx2 = cx1 + clipSpans->len; - - if (cx1 < sx1 && cx2 < sx1) { - ++clipSpans; - continue; - } else if (sx1 < cx1 && sx2 < cx1) { - ++spans; - continue; - } - int x = MAX(sx1, cx1); - int 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; + 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; - SW_FT_Span cspans[NSPANS]; - Span_Data *fill_data = (Span_Data *) user_data; - Clip_Data clip = fill_data->clip; - - clip_count = eina_array_count(clip.clips); - for (i = 0; i < clip_count ; i ++) - { - Eina_Rectangle *rect = (Eina_Rectangle *)eina_array_data_get(clip.clips, i); - Eina_Rectangle tmpRect; + const int NSPANS = 256; + int clip_count, i; + SW_FT_Span cspans[NSPANS]; + 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; + + + 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 - tmpRect.x = rect->x - fill_data->offx; - tmpRect.y = rect->y - fill_data->offy; - tmpRect.w = rect->w; - tmpRect.h = rect->h; + 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) { - SW_FT_Span *clipped = cspans; - spans = _intersect_spans_rect(&tmpRect,spans, end, &clipped, NSPANS); + clipped = cspans; + spans = _intersect_spans_rect(&tmp_rect, spans, end, &clipped, NSPANS); if (clipped - cspans) fill_data->unclipped_blend(clipped - cspans, cspans, fill_data); } - } + } } static void _span_fill_clipPath(int span_count, const SW_FT_Span *spans, void *user_data) { - const int NSPANS = 256; - int current_clip = 0; - SW_FT_Span cspans[NSPANS]; - Span_Data *fill_data = (Span_Data *) user_data; - Clip_Data clip = fill_data->clip; - - //TODO take clip path offset into account. - - const SW_FT_Span *end = spans + span_count; - while (spans < end) - { - SW_FT_Span *clipped = cspans; - spans = _intersect_spans_region(clip.path, ¤t_clip, spans, end, &clipped, NSPANS); - if (clipped - cspans) - fill_data->unclipped_blend(clipped - cspans, cspans, fill_data); - } + const int NSPANS = 256; + int current_clip = 0; + SW_FT_Span cspans[NSPANS]; + Span_Data *fill_data = (Span_Data *) user_data; + Clip_Data clip = fill_data->clip; + SW_FT_Span *clipped; + + //TODO 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, NSPANS); + if (clipped - cspans) + fill_data->unclipped_blend(clipped - cspans, cspans, fill_data); + } } static void @@ -270,19 +265,19 @@ _adjust_span_fill_methods(Span_Data *spdata) { switch(spdata->type) { - case None: - spdata->unclipped_blend = 0; - break; - case Solid: - spdata->unclipped_blend = &_blend_color_argb; - break; - case LinearGradient: - case RadialGradient: - spdata->unclipped_blend = &_blend_gradient; - break; - case Image: - spdata->unclipped_blend = 0;//&_blend_image; - break; + case None: + spdata->unclipped_blend = 0; + break; + case Solid: + spdata->unclipped_blend = &_blend_color_argb; + break; + case LinearGradient: + case RadialGradient: + spdata->unclipped_blend = &_blend_gradient; + break; + case Image: + spdata->unclipped_blend = 0;//&_blend_image; + break; } // setup clipping @@ -317,6 +312,7 @@ 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; + init_draw_helper(); } void ector_software_rasterizer_done(Software_Rasterizer *rasterizer) @@ -325,40 +321,38 @@ void ector_software_rasterizer_done(Software_Rasterizer *rasterizer) SW_FT_Stroker_Done(rasterizer->stroker); } - void ector_software_rasterizer_stroke_set(Software_Rasterizer *rasterizer, double width, Efl_Gfx_Cap cap_style, Efl_Gfx_Join join_style) { SW_FT_Stroker_LineCap cap; SW_FT_Stroker_LineJoin join; + int 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; + 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; - break; + 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; + break; } - - int stroke_width = (int)(width * 64); SW_FT_Stroker_Set(rasterizer->stroker, stroke_width, cap, join, 0); } @@ -371,7 +365,7 @@ _rle_generation_cb( int count, const SW_FT_Span* spans,void *user) // 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) + if (rle->alloc < newsize) { rle->spans = (SW_FT_Span *) realloc(rle->spans, newsize * sizeof(SW_FT_Span)); rle->alloc = newsize; @@ -425,18 +419,19 @@ Shape_Rle_Data * ector_software_rasterizer_generate_stroke_rle_data(Software_Rasterizer *rasterizer, SW_FT_Outline *outline, Eina_Bool closePath) { uint points,contors; + Shape_Rle_Data *rle_data; + SW_FT_Outline strokeOutline = { 0, 0, NULL, NULL, NULL, 0 }; SW_FT_Stroker_ParseOutline(rasterizer->stroker, outline, !closePath); SW_FT_Stroker_GetCounts(rasterizer->stroker,&points, &contors); - SW_FT_Outline strokeOutline = { 0, 0, NULL, NULL, NULL, 0 }; 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(rasterizer->stroker, &strokeOutline); - Shape_Rle_Data *rle_data = ector_software_rasterizer_generate_rle_data(rasterizer, &strokeOutline); + rle_data = ector_software_rasterizer_generate_rle_data(rasterizer, &strokeOutline); // cleanup the outline data. free(strokeOutline.points); @@ -503,20 +498,24 @@ void ector_software_rasterizer_color_set(Software_Rasterizer *rasterizer, int r, rasterizer->fill_data.color = ECTOR_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) + +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) + +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, uint mul_col, Ector_Rop op, Shape_Rle_Data* rle) + int x, int y, uint mul_col, + Ector_Rop op, Shape_Rle_Data* rle) { // check for NULL rle data if (!rle) return; @@ -529,6 +528,6 @@ void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, _setup_span_fill_matrix(rasterizer); _adjust_span_fill_methods(&rasterizer->fill_data); - if(rasterizer->fill_data.blend) + if (rasterizer->fill_data.blend) rasterizer->fill_data.blend(rle->size, rle->spans, &rasterizer->fill_data); } --