forked from enlightenment/efl
split up nasty smooth scaler code to separate parts - they are #included
though for speed reasons, but this makes it more maintainable. SVN revision: 8726
This commit is contained in:
parent
c58bae0364
commit
95355ffdc1
|
|
@ -47,9 +47,17 @@ evas_rectangle_main.c \
|
|||
evas_scale_main.c \
|
||||
evas_scale_sample.c \
|
||||
evas_scale_smooth.c \
|
||||
evas_tiler.c
|
||||
evas_tiler.c \
|
||||
evas_blend_ops.h
|
||||
|
||||
EXTRA_DIST = evas_scale_smooth_scaler.c
|
||||
EXTRA_DIST = \
|
||||
evas_scale_smooth_scaler.c \
|
||||
evas_scale_smooth_scaler_down.c \
|
||||
evas_scale_smooth_scaler_downx.c \
|
||||
evas_scale_smooth_scaler_downx_downy.c \
|
||||
evas_scale_smooth_scaler_downy.c \
|
||||
evas_scale_smooth_scaler_noscale.c \
|
||||
evas_scale_smooth_scaler_up.c
|
||||
|
||||
libevas_engine_common_la_LIBADD = \
|
||||
$(LDFLAGS)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,199 @@
|
|||
#ifndef EVAS_BLEND_OPS_H
|
||||
#define EVAS_BLEND_OPS_H
|
||||
|
||||
#define BLEND_RGBA_RGBA_C(src, dst) \
|
||||
{ \
|
||||
DATA32 __tmp; \
|
||||
DATA8 __a; \
|
||||
\
|
||||
if (A_VAL(src)) /* hmmm - do we need this? */ \
|
||||
{ \
|
||||
__a = _evas_pow_lut[A_VAL(src)][A_VAL(dst)]; \
|
||||
BLEND_COLOR(__a, R_VAL(dst), \
|
||||
R_VAL(src), R_VAL(dst), \
|
||||
__tmp); \
|
||||
BLEND_COLOR(__a, G_VAL(dst), \
|
||||
G_VAL(src), G_VAL(dst), \
|
||||
__tmp); \
|
||||
BLEND_COLOR(__a, B_VAL(dst), \
|
||||
B_VAL(src), B_VAL(dst), \
|
||||
__tmp); \
|
||||
A_VAL(dst) = A_VAL(dst) + ((A_VAL(src) * (255 - A_VAL(dst))) / 255);\
|
||||
} \
|
||||
}
|
||||
|
||||
#define BLEND_RGBA_RGB_C(src, dst) \
|
||||
{ \
|
||||
DATA32 __tmp; \
|
||||
\
|
||||
if (A_VAL(src)) /* hmmm - do we need this? */ \
|
||||
{ \
|
||||
BLEND_COLOR(A_VAL(src), R_VAL(dst), \
|
||||
R_VAL(src), R_VAL(dst), \
|
||||
__tmp); \
|
||||
BLEND_COLOR(A_VAL(src), G_VAL(dst), \
|
||||
G_VAL(src), G_VAL(dst), \
|
||||
__tmp); \
|
||||
BLEND_COLOR(A_VAL(src), B_VAL(dst), \
|
||||
B_VAL(src), B_VAL(dst), \
|
||||
__tmp); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGBA_C(src, dst) \
|
||||
{ \
|
||||
*dst = *src | PIXEL_SOLID_ALPHA; \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGB_C(src, dst) \
|
||||
{ \
|
||||
*dst = *src; \
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define BLEND_RGBA_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
DATA32 __tmp; \
|
||||
\
|
||||
movd_r2m(src_mmx, __tmp); \
|
||||
BLEND_RGBA_RGBA_C(&__tmp, dst); \
|
||||
}
|
||||
|
||||
#define BLEND_RGBA_RGBA_MMX_Z_C1(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGBA_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
#define BLEND_RGBA_RGBA_MMX_Z(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGBA_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define BLEND_RGBA_RGB_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
movd_m2r(dst[0], mmx1); \
|
||||
\
|
||||
movq_r2r(src_mmx, mmx2); \
|
||||
punpcklbw_r2r(mmx2, mmx2); \
|
||||
punpckhwd_r2r(mmx2, mmx2); \
|
||||
punpckhdq_r2r(mmx2, mmx2); \
|
||||
psrlw_i2r(1, mmx2); \
|
||||
\
|
||||
psrlq_i2r(16, mmx2); \
|
||||
\
|
||||
pxor_r2r(mmxz, mmxz); \
|
||||
punpcklbw_r2r(mmxz, src_mmx); \
|
||||
punpcklbw_r2r(mmxz, mmx1); \
|
||||
\
|
||||
psubw_r2r(mmx1, src_mmx); \
|
||||
psllw_i2r(1, src_mmx); \
|
||||
movq_m2r(*_evas_const_c1, mmxc1); \
|
||||
paddw_r2r(mmxc1, src_mmx); \
|
||||
pmulhw_r2r(mmx2, src_mmx); \
|
||||
paddw_r2r(src_mmx, mmx1); \
|
||||
\
|
||||
packuswb_r2r(mmxz, mmx1); \
|
||||
movd_r2m(mmx1, dst[0]); \
|
||||
}
|
||||
|
||||
#define BLEND_RGBA_RGB_MMX_Z_C1(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
movd_m2r(dst[0], mmx1); \
|
||||
\
|
||||
movq_r2r(src_mmx, mmx2); \
|
||||
punpcklbw_r2r(mmx2, mmx2); \
|
||||
punpckhwd_r2r(mmx2, mmx2); \
|
||||
punpckhdq_r2r(mmx2, mmx2); \
|
||||
psrlw_i2r(1, mmx2); \
|
||||
\
|
||||
psrlq_i2r(16, mmx2); \
|
||||
\
|
||||
punpcklbw_r2r(mmxz, src_mmx); \
|
||||
punpcklbw_r2r(mmxz, mmx1); \
|
||||
\
|
||||
psubw_r2r(mmx1, src_mmx); \
|
||||
psllw_i2r(1, src_mmx); \
|
||||
paddw_r2r(mmxc1, src_mmx); \
|
||||
pmulhw_r2r(mmx2, src_mmx); \
|
||||
paddw_r2r(src_mmx, mmx1); \
|
||||
\
|
||||
packuswb_r2r(mmxz, mmx1); \
|
||||
movd_r2m(mmx1, dst[0]); \
|
||||
}
|
||||
|
||||
#define BLEND_RGBA_RGB_MMX_Z(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
movd_m2r(dst[0], mmx1); \
|
||||
\
|
||||
movq_r2r(src_mmx, mmx2); \
|
||||
punpcklbw_r2r(mmx2, mmx2); \
|
||||
punpckhwd_r2r(mmx2, mmx2); \
|
||||
punpckhdq_r2r(mmx2, mmx2); \
|
||||
psrlw_i2r(1, mmx2); \
|
||||
\
|
||||
psrlq_i2r(16, mmx2); \
|
||||
\
|
||||
punpcklbw_r2r(mmxz, src_mmx); \
|
||||
punpcklbw_r2r(mmxz, mmx1); \
|
||||
\
|
||||
psubw_r2r(mmx1, src_mmx); \
|
||||
psllw_i2r(1, src_mmx); \
|
||||
movq_m2r(*_evas_const_c1, mmxc1); \
|
||||
paddw_r2r(mmxc1, src_mmx); \
|
||||
pmulhw_r2r(mmx2, src_mmx); \
|
||||
paddw_r2r(src_mmx, mmx1); \
|
||||
\
|
||||
packuswb_r2r(mmxz, mmx1); \
|
||||
movd_r2m(mmx1, dst[0]); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define BLEND_RGB_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
DATA32 __tmp; \
|
||||
\
|
||||
movd_r2m(src_mmx, __tmp); \
|
||||
BLEND_RGB_RGBA_C(&__tmp, dst); \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGBA_MMX_Z_C1(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGB_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGBA_MMX_Z(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGB_RGBA_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define BLEND_RGB_RGB_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
movd_r2m(src_mmx, dst[0]); \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGB_MMX_Z_C1(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGB_RGB_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
#define BLEND_RGB_RGB_MMX_Z(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1) \
|
||||
{ \
|
||||
BLEND_RGB_RGB_MMX(src_mmx, dst, mmx1, mmx2, mmxz, mmxc1); \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -147,12 +147,6 @@ evas_common_image_free(RGBA_Image *im)
|
|||
int i;
|
||||
|
||||
if (im->image) evas_common_image_surface_free(im->image);
|
||||
for (i = 0; i < im->mipmaps.num; i++)
|
||||
{
|
||||
if (im->mipmaps.levels[i])
|
||||
evas_common_image_surface_free(im->mipmaps.levels[i]);
|
||||
}
|
||||
if (im->mipmaps.levels) free(im->mipmaps.levels);
|
||||
if (im->info.file) free(im->info.file);
|
||||
if (im->info.real_file) free(im->info.real_file);
|
||||
if (im->info.key) free(im->info.key);
|
||||
|
|
@ -404,12 +398,6 @@ evas_common_image_ram_usage(RGBA_Image *im)
|
|||
if (im->info.comment) ram += strlen(im->info.comment);
|
||||
if ((im->image) && (im->image->data) && (!im->image->no_free))
|
||||
ram += im->image->w * im->image->h * sizeof(DATA32);
|
||||
ram += im->mipmaps.num * sizeof(RGBA_Surface);
|
||||
for (i = 0; i < im->mipmaps.num; i++)
|
||||
{
|
||||
if ((im->mipmaps.levels[i]) && (im->mipmaps.levels[i]->data) && (!im->mipmaps.levels[i]->no_free))
|
||||
ram += im->mipmaps.levels[i]->w * im->mipmaps.levels[i]->h * sizeof(DATA32);
|
||||
}
|
||||
return ram;
|
||||
}
|
||||
|
||||
|
|
@ -420,7 +408,5 @@ evas_common_image_dirty(RGBA_Image *im)
|
|||
|
||||
evas_common_image_unstore(im);
|
||||
im->flags |= RGBA_IMAGE_IS_DIRTY;
|
||||
for (i = 0; i < im->mipmaps.num; i++)
|
||||
evas_common_image_surface_dealloc(im->mipmaps.levels[i]);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,11 @@
|
|||
#include "evas_mmx.h"
|
||||
#endif
|
||||
|
||||
#include "evas_blend_ops.h"
|
||||
|
||||
extern DATA8 _evas_pow_lut[256][256];
|
||||
extern const DATA16 _evas_const_c1[4];
|
||||
|
||||
static DATA32 **scale_calc_y_points(DATA32 *src, int sw, int sh, int dh);
|
||||
static int *scale_calc_x_points(int sw, int dw);
|
||||
static int *scale_calc_a_points(int s, int d);
|
||||
|
|
@ -424,220 +429,6 @@ evas_common_scale_rgba_mipmap_down_1x2_mmx(DATA32 *src, DATA32 *dst, int src_w,
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef BUILD_SCALE_SMOOTH
|
||||
void
|
||||
evas_common_scale_rgba_gen_mipmap_table(RGBA_Image *src)
|
||||
{
|
||||
int w, h, i;
|
||||
|
||||
w = src->image->w;
|
||||
h = src->image->h;
|
||||
do
|
||||
{
|
||||
w >>= 1;
|
||||
h >>= 1;
|
||||
if (w < 1) w = 1;
|
||||
if (h < 1) h = 1;
|
||||
src->mipmaps.num++;
|
||||
}
|
||||
while ((w > 1) && (h > 1));
|
||||
if (src->mipmaps.num <= 0) return;
|
||||
src->mipmaps.levels = malloc(sizeof(RGBA_Surface) * src->mipmaps.num);
|
||||
w = src->image->w;
|
||||
h = src->image->h;
|
||||
for (i = 0; i < src->mipmaps.num; i++)
|
||||
{
|
||||
w >>= 1;
|
||||
h >>= 1;
|
||||
if (w < 1) w = 1;
|
||||
if (h < 1) h = 1;
|
||||
src->mipmaps.levels[i] = evas_common_image_surface_new();
|
||||
src->mipmaps.levels[i]->w = w;
|
||||
src->mipmaps.levels[i]->h = h;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BUILD_SCALE_SMOOTH
|
||||
void
|
||||
evas_common_scale_rgba_gen_mipmap_level(RGBA_Image *src, int l)
|
||||
{
|
||||
RGBA_Surface *s_srf, *d_srf;
|
||||
#ifdef BUILD_MMX
|
||||
int mmx, sse, sse2;
|
||||
#endif
|
||||
|
||||
if (src->mipmaps.levels[l]->data) return;
|
||||
evas_common_image_surface_alloc(src->mipmaps.levels[l]);
|
||||
if (l > 0)
|
||||
evas_common_scale_rgba_gen_mipmap_level(src, l - 1);
|
||||
if (l > 0)
|
||||
s_srf = src->mipmaps.levels[l - 1];
|
||||
else
|
||||
s_srf = src->image;
|
||||
d_srf = src->mipmaps.levels[l];
|
||||
#ifdef BUILD_MMX
|
||||
evas_common_cpu_can_do(&mmx, &sse, &sse2);
|
||||
if (mmx)
|
||||
{
|
||||
if ((s_srf->w > 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgba_mipmap_down_2x2_mmx(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w > 1) && (s_srf->h <= 1))
|
||||
evas_common_scale_rgba_mipmap_down_2x1_mmx(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w <= 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgba_mipmap_down_1x2_mmx(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
}
|
||||
else
|
||||
{
|
||||
#endif
|
||||
#ifdef BUILD_C
|
||||
if (src->flags & RGBA_IMAGE_HAS_ALPHA)
|
||||
{
|
||||
if ((s_srf->w > 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgba_mipmap_down_2x2_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w > 1) && (s_srf->h <= 1))
|
||||
evas_common_scale_rgba_mipmap_down_2x1_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w <= 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgba_mipmap_down_1x2_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((s_srf->w > 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgb_mipmap_down_2x2_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w > 1) && (s_srf->h <= 1))
|
||||
evas_common_scale_rgb_mipmap_down_2x1_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
else if ((s_srf->w <= 1) && (s_srf->h > 1))
|
||||
evas_common_scale_rgb_mipmap_down_1x2_c(s_srf->data, d_srf->data, s_srf->w, s_srf->h);
|
||||
}
|
||||
#endif
|
||||
#ifdef BUILD_MMX
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BUILD_SCALE_SMOOTH
|
||||
#ifdef BUILD_SCALE_TRILINEAR
|
||||
int
|
||||
evas_common_scale_rgba_get_mipmap_surfaces(RGBA_Image *src, int src_region_w, int src_region_h, int dst_region_w, int dst_region_h, RGBA_Surface **srf1, RGBA_Surface **srf2)
|
||||
{
|
||||
int scale_x, scale_y;
|
||||
int l, l1, l2;
|
||||
int mix, pw, ph;
|
||||
int w, h;
|
||||
int dw, dh;
|
||||
|
||||
scale_x = (dst_region_w << 16) / src_region_w;
|
||||
scale_y = (dst_region_h << 16) / src_region_h;
|
||||
|
||||
mix = 0;
|
||||
l1 = -1;
|
||||
l2 = -1;
|
||||
w = src->image->w;
|
||||
h = src->image->h;
|
||||
dw = (dst_region_w * src->image->w) / src_region_w;
|
||||
dh = (dst_region_h * src->image->h) / src_region_h;
|
||||
|
||||
/* if we prefer smoothened use smaller scaling axis */
|
||||
if (scale_x < scale_y)
|
||||
/* use x axis */
|
||||
{
|
||||
for (l = 0; l < src->mipmaps.num; l++)
|
||||
{
|
||||
pw = w;
|
||||
w >>=1;
|
||||
if (dw > w)
|
||||
{
|
||||
mix = ((dw - w) << 8) / (pw - w);
|
||||
l1 = l - 1;
|
||||
l2 = l;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
/* use y axis */
|
||||
{
|
||||
for (l = 0; l < src->mipmaps.num; l++)
|
||||
{
|
||||
ph = h;
|
||||
h >>=1;
|
||||
if (dh > h)
|
||||
{
|
||||
mix = ((dh - h) << 8) / (ph - h);
|
||||
l1 = l - 1;
|
||||
l2 = l;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (l1 == -1) *srf1 = src->image;
|
||||
else
|
||||
{
|
||||
evas_common_scale_rgba_gen_mipmap_level(src, l1);
|
||||
*srf1 = src->mipmaps.levels[l1];
|
||||
}
|
||||
if (l2 == -1) *srf2 = src->image;
|
||||
else
|
||||
{
|
||||
evas_common_scale_rgba_gen_mipmap_level(src, l2);
|
||||
*srf2 = src->mipmaps.levels[l2];
|
||||
}
|
||||
return mix;
|
||||
}
|
||||
#else
|
||||
RGBA_Surface *
|
||||
evas_common_scale_rgba_get_mipmap_surface(RGBA_Image *src, int src_region_w, int src_region_h, int dst_region_w, int dst_region_h)
|
||||
{
|
||||
int scale_x, scale_y;
|
||||
int l;
|
||||
int pw, ph;
|
||||
int w, h;
|
||||
int dw, dh;
|
||||
RGBA_Surface *srf;
|
||||
|
||||
scale_x = (dst_region_w << 16) / src_region_w;
|
||||
scale_y = (dst_region_h << 16) / src_region_h;
|
||||
|
||||
w = src->image->w;
|
||||
h = src->image->h;
|
||||
dw = (dst_region_w * src->image->w) / src_region_w;
|
||||
dh = (dst_region_h * src->image->h) / src_region_h;
|
||||
|
||||
/* if we prefer smoothened use larger scaling axis */
|
||||
if (scale_x > scale_y)
|
||||
/* use x axis */
|
||||
{
|
||||
for (l = 0; l < src->mipmaps.num; l++)
|
||||
{
|
||||
pw = w;
|
||||
w >>=1;
|
||||
if (dw > w) break;
|
||||
}
|
||||
}
|
||||
else
|
||||
/* use y axis */
|
||||
{
|
||||
for (l = 0; l < src->mipmaps.num; l++)
|
||||
{
|
||||
ph = h;
|
||||
h >>=1;
|
||||
if (dh > h) break;
|
||||
}
|
||||
}
|
||||
l--;
|
||||
srf = src->image;
|
||||
if (l == -1) srf = src->image;
|
||||
else
|
||||
{
|
||||
evas_common_scale_rgba_gen_mipmap_level(src, l);
|
||||
srf = src->mipmaps.levels[l];
|
||||
}
|
||||
return srf;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef BUILD_SCALE_SMOOTH
|
||||
# ifdef BUILD_MMX
|
||||
# undef SCALE_FUNC
|
||||
|
|
@ -661,9 +452,7 @@ evas_common_scale_rgba_in_to_out_clip_smooth(RGBA_Image *src, RGBA_Image *dst,
|
|||
int dst_region_w, int dst_region_h)
|
||||
{
|
||||
# ifdef BUILD_MMX
|
||||
# ifndef BUILD_SCALE_TRILINEAR
|
||||
int mmx, sse, sse2;
|
||||
# endif
|
||||
# endif
|
||||
int c, cx, cy, cw, ch;
|
||||
Cutout_Rect *rects, *r;
|
||||
|
|
@ -674,15 +463,12 @@ evas_common_scale_rgba_in_to_out_clip_smooth(RGBA_Image *src, RGBA_Image *dst,
|
|||
if (!(RECTS_INTERSECT(dst_region_x, dst_region_y, dst_region_w, dst_region_h, 0, 0, dst->image->w, dst->image->h)))
|
||||
return;
|
||||
# ifdef BUILD_MMX
|
||||
# ifndef BUILD_SCALE_TRILINEAR
|
||||
evas_common_cpu_can_do(&mmx, &sse, &sse2);
|
||||
# endif
|
||||
# endif
|
||||
/* no cutouts - cut right to the chase */
|
||||
if (!dc->cutout.rects)
|
||||
{
|
||||
# ifdef BUILD_MMX
|
||||
# ifndef BUILD_SCALE_TRILINEAR
|
||||
if (mmx)
|
||||
evas_common_scale_rgba_in_to_out_clip_smooth_mmx(src, dst, dc,
|
||||
src_region_x, src_region_y,
|
||||
|
|
@ -690,7 +476,6 @@ evas_common_scale_rgba_in_to_out_clip_smooth(RGBA_Image *src, RGBA_Image *dst,
|
|||
dst_region_x, dst_region_y,
|
||||
dst_region_w, dst_region_h);
|
||||
else
|
||||
# endif
|
||||
# endif
|
||||
# ifdef BUILD_C
|
||||
evas_common_scale_rgba_in_to_out_clip_smooth_c(src, dst, dc,
|
||||
|
|
@ -717,7 +502,6 @@ evas_common_scale_rgba_in_to_out_clip_smooth(RGBA_Image *src, RGBA_Image *dst,
|
|||
r = (Cutout_Rect *)l;
|
||||
evas_common_draw_context_set_clip(dc, r->x, r->y, r->w, r->h);
|
||||
# ifdef BUILD_MMX
|
||||
# ifndef BUILD_SCALE_TRILINEAR
|
||||
if (mmx)
|
||||
evas_common_scale_rgba_in_to_out_clip_smooth_mmx(src, dst, dc,
|
||||
src_region_x, src_region_y,
|
||||
|
|
@ -725,7 +509,6 @@ evas_common_scale_rgba_in_to_out_clip_smooth(RGBA_Image *src, RGBA_Image *dst,
|
|||
dst_region_x, dst_region_y,
|
||||
dst_region_w, dst_region_h);
|
||||
else
|
||||
# endif
|
||||
# endif
|
||||
# ifdef BUILD_C
|
||||
evas_common_scale_rgba_in_to_out_clip_smooth_c(src, dst, dc,
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,44 @@
|
|||
#define RGBA_COMPOSE(r, g, b, a) ((a) << 24) | ((r) << 16) | ((g) << 8) | (b)
|
||||
#define INV_XAP (256 - xapoints[dxx + x])
|
||||
#define XAP (xapoints[dxx + x])
|
||||
#define INV_YAP (256 - yapoints[dyy + y])
|
||||
#define YAP (yapoints[dyy + y])
|
||||
|
||||
{
|
||||
DATA32 *sptr;
|
||||
int x, y;
|
||||
DATA32 **ypoints;
|
||||
int *xpoints;
|
||||
int *xapoints;
|
||||
int *yapoints;
|
||||
DATA32 *src_data;
|
||||
|
||||
src_data = src->image->data;
|
||||
|
||||
xpoints = scale_calc_x_points(src_region_w, dst_region_w);
|
||||
ypoints = scale_calc_y_points(src_data, src->image->w, src_region_h, dst_region_h);
|
||||
xapoints = scale_calc_a_points(src_region_w, dst_region_w);
|
||||
yapoints = scale_calc_a_points(src_region_h, dst_region_h);
|
||||
/* scaling down vertically */
|
||||
if ((dst_region_w >= src_region_w) &&
|
||||
(dst_region_h < src_region_h))
|
||||
{
|
||||
#include "evas_scale_smooth_scaler_downy.c"
|
||||
}
|
||||
/* scaling down horizontally */
|
||||
else if ((dst_region_w < src_region_w) &&
|
||||
(dst_region_h >= src_region_h))
|
||||
{
|
||||
#include "evas_scale_smooth_scaler_downx.c"
|
||||
}
|
||||
/* scaling down both vertically & horizontally */
|
||||
else if ((dst_region_w < src_region_w) &&
|
||||
(dst_region_h < src_region_h))
|
||||
{
|
||||
#include "evas_scale_smooth_scaler_downx_downy.c"
|
||||
}
|
||||
free(xpoints);
|
||||
free(ypoints);
|
||||
free(xapoints);
|
||||
free(yapoints);
|
||||
}
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
{
|
||||
int Cx, j;
|
||||
DATA32 *pix;
|
||||
int r, g, b, a, rr, gg, bb, aa;
|
||||
int xap;
|
||||
int sow;
|
||||
int dyy, dxx;
|
||||
|
||||
dptr = dst_ptr;
|
||||
sow = src->image->w;
|
||||
dyy = dst_clip_y - dst_region_y;
|
||||
dxx = dst_clip_x - dst_region_x;
|
||||
if (src->flags & RGBA_IMAGE_HAS_ALPHA)
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
Cx = XAP >> 16;
|
||||
xap = XAP & 0xffff;
|
||||
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
r = (R_VAL(pix) * xap) >> 10;
|
||||
g = (G_VAL(pix) * xap) >> 10;
|
||||
b = (B_VAL(pix) * xap) >> 10;
|
||||
a = (A_VAL(pix) * xap) >> 10;
|
||||
for (j = (1 << 14) - xap; j > Cx; j -= Cx)
|
||||
{
|
||||
pix++;
|
||||
r += (R_VAL(pix) * Cx) >> 10;
|
||||
g += (G_VAL(pix) * Cx) >> 10;
|
||||
b += (B_VAL(pix) * Cx) >> 10;
|
||||
a += (A_VAL(pix) * Cx) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix++;
|
||||
r += (R_VAL(pix) * j) >> 10;
|
||||
g += (G_VAL(pix) * j) >> 10;
|
||||
b += (B_VAL(pix) * j) >> 10;
|
||||
a += (A_VAL(pix) * j) >> 10;
|
||||
}
|
||||
if (YAP > 0)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + sow + (src_region_y * sow) + src_region_x;
|
||||
rr = (R_VAL(pix) * xap) >> 10;
|
||||
gg = (G_VAL(pix) * xap) >> 10;
|
||||
bb = (B_VAL(pix) * xap) >> 10;
|
||||
aa = (A_VAL(pix) * xap) >> 10;
|
||||
for (j = (1 << 14) - xap; j > Cx; j -= Cx)
|
||||
{
|
||||
pix++;
|
||||
rr += (R_VAL(pix) * Cx) >> 10;
|
||||
gg += (G_VAL(pix) * Cx) >> 10;
|
||||
bb += (B_VAL(pix) * Cx) >> 10;
|
||||
aa += (A_VAL(pix) * Cx) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix++;
|
||||
rr += (R_VAL(pix) * j) >> 10;
|
||||
gg += (G_VAL(pix) * j) >> 10;
|
||||
bb += (B_VAL(pix) * j) >> 10;
|
||||
aa += (A_VAL(pix) * j) >> 10;
|
||||
}
|
||||
r = r * INV_YAP;
|
||||
g = g * INV_YAP;
|
||||
b = b * INV_YAP;
|
||||
a = a * INV_YAP;
|
||||
r = (r + ((rr * YAP))) >> 12;
|
||||
g = (g + ((gg * YAP))) >> 12;
|
||||
b = (b + ((bb * YAP))) >> 12;
|
||||
a = (a + ((aa * YAP))) >> 12;
|
||||
}
|
||||
else
|
||||
{
|
||||
r >>= 4;
|
||||
g >>= 4;
|
||||
b >>= 4;
|
||||
a >>= 4;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r, g, b, a);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
Cx = XAP >> 16;
|
||||
xap = XAP & 0xffff;
|
||||
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
r = (R_VAL(pix) * xap) >> 10;
|
||||
g = (G_VAL(pix) * xap) >> 10;
|
||||
b = (B_VAL(pix) * xap) >> 10;
|
||||
for (j = (1 << 14) - xap; j > Cx; j -= Cx)
|
||||
{
|
||||
pix++;
|
||||
r += (R_VAL(pix) * Cx) >> 10;
|
||||
g += (G_VAL(pix) * Cx) >> 10;
|
||||
b += (B_VAL(pix) * Cx) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix++;
|
||||
r += (R_VAL(pix) * j) >> 10;
|
||||
g += (G_VAL(pix) * j) >> 10;
|
||||
b += (B_VAL(pix) * j) >> 10;
|
||||
}
|
||||
if (YAP > 0)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + sow + (src_region_y * sow) + src_region_x;
|
||||
rr = (R_VAL(pix) * xap) >> 10;
|
||||
gg = (G_VAL(pix) * xap) >> 10;
|
||||
bb = (B_VAL(pix) * xap) >> 10;
|
||||
for (j = (1 << 14) - xap; j > Cx; j -= Cx)
|
||||
{
|
||||
pix++;
|
||||
rr += (R_VAL(pix) * Cx) >> 10;
|
||||
gg += (G_VAL(pix) * Cx) >> 10;
|
||||
bb += (B_VAL(pix) * Cx) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix++;
|
||||
rr += (R_VAL(pix) * j) >> 10;
|
||||
gg += (G_VAL(pix) * j) >> 10;
|
||||
bb += (B_VAL(pix) * j) >> 10;
|
||||
}
|
||||
r = r * INV_YAP;
|
||||
g = g * INV_YAP;
|
||||
b = b * INV_YAP;
|
||||
r = (r + ((rr * YAP))) >> 12;
|
||||
g = (g + ((gg * YAP))) >> 12;
|
||||
b = (b + ((bb * YAP))) >> 12;
|
||||
}
|
||||
else
|
||||
{
|
||||
r >>= 4;
|
||||
g >>= 4;
|
||||
b >>= 4;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r, g, b, 0xff);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,231 @@
|
|||
{
|
||||
int Cx, Cy, i, j;
|
||||
DATA32 *pix;
|
||||
int a, r, g, b, rx, gx, bx, ax;
|
||||
int xap, yap;
|
||||
int sow;
|
||||
int dyy, dxx;
|
||||
|
||||
dptr = dst_ptr;
|
||||
sow = src->image->w;
|
||||
dyy = dst_clip_y - dst_region_y;
|
||||
dxx = dst_clip_x - dst_region_x;
|
||||
/*#ifndef SCALE_USING_MMX */
|
||||
/* for now there's no mmx down scaling - so C only */
|
||||
#if 1
|
||||
if (src->flags & RGBA_IMAGE_HAS_ALPHA)
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
Cy = YAP >> 16;
|
||||
yap = YAP & 0xffff;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
Cx = XAP >> 16;
|
||||
xap = XAP & 0xffff;
|
||||
|
||||
sptr = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
ax = (A_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
ax += (A_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
ax += (A_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r = (rx * yap) >> 14;
|
||||
g = (gx * yap) >> 14;
|
||||
b = (bx * yap) >> 14;
|
||||
a = (ax * yap) >> 14;
|
||||
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
ax = (A_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
ax += (A_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
ax += (A_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r += (rx * Cy) >> 14;
|
||||
g += (gx * Cy) >> 14;
|
||||
b += (bx * Cy) >> 14;
|
||||
a += (ax * Cy) >> 14;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
ax = (A_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
ax += (A_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
ax += (A_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r += (rx * j) >> 14;
|
||||
g += (gx * j) >> 14;
|
||||
b += (bx * j) >> 14;
|
||||
a += (ax * j) >> 14;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r >> 5, g >> 5, b >> 5, a >> 5);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
Cy = YAP >> 16;
|
||||
yap = YAP & 0xffff;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
Cx = XAP >> 16;
|
||||
xap = XAP & 0xffff;
|
||||
|
||||
sptr = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r = (rx * yap) >> 14;
|
||||
g = (gx * yap) >> 14;
|
||||
b = (bx * yap) >> 14;
|
||||
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r += (rx * Cy) >> 14;
|
||||
g += (gx * Cy) >> 14;
|
||||
b += (bx * Cy) >> 14;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix = sptr;
|
||||
sptr += sow;
|
||||
rx = (R_VAL(pix) * xap) >> 9;
|
||||
gx = (G_VAL(pix) * xap) >> 9;
|
||||
bx = (B_VAL(pix) * xap) >> 9;
|
||||
pix++;
|
||||
for (i = (1 << 14) - xap; i > Cx; i -= Cx)
|
||||
{
|
||||
rx += (R_VAL(pix) * Cx) >> 9;
|
||||
gx += (G_VAL(pix) * Cx) >> 9;
|
||||
bx += (B_VAL(pix) * Cx) >> 9;
|
||||
pix++;
|
||||
}
|
||||
if (i > 0)
|
||||
{
|
||||
rx += (R_VAL(pix) * i) >> 9;
|
||||
gx += (G_VAL(pix) * i) >> 9;
|
||||
bx += (B_VAL(pix) * i) >> 9;
|
||||
}
|
||||
|
||||
r += (rx * j) >> 14;
|
||||
g += (gx * j) >> 14;
|
||||
b += (bx * j) >> 14;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r >> 5, g >> 5, b >> 5, 0xff);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
#else
|
||||
/* MMX scaling down would go here */
|
||||
#endif
|
||||
}
|
||||
|
|
@ -0,0 +1,162 @@
|
|||
{
|
||||
int Cy, j;
|
||||
DATA32 *pix;
|
||||
int r, g, b, a, rr, gg, bb, aa;
|
||||
int yap;
|
||||
int sow;
|
||||
int dyy, dxx;
|
||||
|
||||
dptr = dst_ptr;
|
||||
sow = src->image->w;
|
||||
dyy = dst_clip_y - dst_region_y;
|
||||
dxx = dst_clip_x - dst_region_x;
|
||||
if (src->flags & RGBA_IMAGE_HAS_ALPHA)
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
Cy = YAP >> 16;
|
||||
yap = YAP & 0xffff;
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
r = (R_VAL(pix) * yap) >> 10;
|
||||
g = (G_VAL(pix) * yap) >> 10;
|
||||
b = (B_VAL(pix) * yap) >> 10;
|
||||
a = (A_VAL(pix) * yap) >> 10;
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix += sow;
|
||||
r += (R_VAL(pix) * Cy) >> 10;
|
||||
g += (G_VAL(pix) * Cy) >> 10;
|
||||
b += (B_VAL(pix) * Cy) >> 10;
|
||||
a += (A_VAL(pix) * Cy) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix += sow;
|
||||
r += (R_VAL(pix) * j) >> 10;
|
||||
g += (G_VAL(pix) * j) >> 10;
|
||||
b += (B_VAL(pix) * j) >> 10;
|
||||
a += (A_VAL(pix) * j) >> 10;
|
||||
}
|
||||
if (XAP > 0)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + 1 + (src_region_y * sow) + src_region_x;
|
||||
rr = (R_VAL(pix) * yap) >> 10;
|
||||
gg = (G_VAL(pix) * yap) >> 10;
|
||||
bb = (B_VAL(pix) * yap) >> 10;
|
||||
aa = (A_VAL(pix) * yap) >> 10;
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix += sow;
|
||||
rr += (R_VAL(pix) * Cy) >> 10;
|
||||
gg += (G_VAL(pix) * Cy) >> 10;
|
||||
bb += (B_VAL(pix) * Cy) >> 10;
|
||||
aa += (A_VAL(pix) * Cy) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix += sow;
|
||||
rr += (R_VAL(pix) * j) >> 10;
|
||||
gg += (G_VAL(pix) * j) >> 10;
|
||||
bb += (B_VAL(pix) * j) >> 10;
|
||||
aa += (A_VAL(pix) * j) >> 10;
|
||||
}
|
||||
r = r * INV_XAP;
|
||||
g = g * INV_XAP;
|
||||
b = b * INV_XAP;
|
||||
a = a * INV_XAP;
|
||||
r = (r + ((rr * XAP))) >> 12;
|
||||
g = (g + ((gg * XAP))) >> 12;
|
||||
b = (b + ((bb * XAP))) >> 12;
|
||||
a = (a + ((aa * XAP))) >> 12;
|
||||
}
|
||||
else
|
||||
{
|
||||
r >>= 4;
|
||||
g >>= 4;
|
||||
b >>= 4;
|
||||
a >>= 4;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r, g, b, a);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
Cy = YAP >> 16;
|
||||
yap = YAP & 0xffff;
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + (src_region_y * sow) + src_region_x;
|
||||
r = (R_VAL(pix) * yap) >> 10;
|
||||
g = (G_VAL(pix) * yap) >> 10;
|
||||
b = (B_VAL(pix) * yap) >> 10;
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix += sow;
|
||||
r += (R_VAL(pix) * Cy) >> 10;
|
||||
g += (G_VAL(pix) * Cy) >> 10;
|
||||
b += (B_VAL(pix) * Cy) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix += sow;
|
||||
r += (R_VAL(pix) * j) >> 10;
|
||||
g += (G_VAL(pix) * j) >> 10;
|
||||
b += (B_VAL(pix) * j) >> 10;
|
||||
}
|
||||
if (XAP > 0)
|
||||
{
|
||||
pix = ypoints[dyy + y] + xpoints[dxx + x] + 1 + (src_region_y * sow) + src_region_x;
|
||||
rr = (R_VAL(pix) * yap) >> 10;
|
||||
gg = (G_VAL(pix) * yap) >> 10;
|
||||
bb = (B_VAL(pix) * yap) >> 10;
|
||||
for (j = (1 << 14) - yap; j > Cy; j -= Cy)
|
||||
{
|
||||
pix += sow;
|
||||
rr += (R_VAL(pix) * Cy) >> 10;
|
||||
gg += (G_VAL(pix) * Cy) >> 10;
|
||||
bb += (B_VAL(pix) * Cy) >> 10;
|
||||
}
|
||||
if (j > 0)
|
||||
{
|
||||
pix += sow;
|
||||
rr += (R_VAL(pix) * j) >> 10;
|
||||
gg += (G_VAL(pix) * j) >> 10;
|
||||
bb += (B_VAL(pix) * j) >> 10;
|
||||
}
|
||||
r = r * INV_XAP;
|
||||
g = g * INV_XAP;
|
||||
b = b * INV_XAP;
|
||||
r = (r + ((rr * XAP))) >> 12;
|
||||
g = (g + ((gg * XAP))) >> 12;
|
||||
b = (b + ((bb * XAP))) >> 12;
|
||||
}
|
||||
else
|
||||
{
|
||||
r >>= 4;
|
||||
g >>= 4;
|
||||
b >>= 4;
|
||||
}
|
||||
buf[x] = RGBA_COMPOSE(r, g, b, 0xff);
|
||||
}
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
{
|
||||
DATA32 *src_data;
|
||||
|
||||
src_data = src->image->data;
|
||||
ptr = src_data + ((dst_clip_y - dst_region_y + src_region_y) * src_w) + (dst_clip_x - dst_region_x) + src_region_x;
|
||||
if (dc->mod.use)
|
||||
{
|
||||
Gfx_Func_Blend_Src_Cmod_Dst func;
|
||||
|
||||
func = evas_common_draw_func_blend_cmod_get(src, dst, dst_clip_w);
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
func(ptr, dst_ptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
ptr += src_w;
|
||||
dst_ptr += dst_w;
|
||||
}
|
||||
}
|
||||
else if (dc->mul.use)
|
||||
{
|
||||
Gfx_Func_Blend_Src_Mul_Dst func;
|
||||
|
||||
func = evas_common_draw_func_blend_mul_get(src, dc->mul.col, dst, dst_clip_w);
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
func(ptr, dst_ptr, dst_clip_w, dc->mul.col);
|
||||
ptr += src_w;
|
||||
dst_ptr += dst_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Gfx_Func_Blend_Src_Dst func;
|
||||
|
||||
func = evas_common_draw_func_blend_get(src, dst, dst_clip_w);
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
func(ptr, dst_ptr, dst_clip_w);
|
||||
ptr += src_w;
|
||||
dst_ptr += dst_w;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,398 @@
|
|||
{
|
||||
DATA32 *src_data;
|
||||
|
||||
src_data = src->image->data;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
if (src_region_w > 1)
|
||||
{
|
||||
lin_ptr[x] = (((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) / dst_region_w);
|
||||
if (dst_region_w > 262144)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w))) / dst_region_w) -
|
||||
(lin_ptr[x])) << 8;
|
||||
else if (dst_region_w > 131072)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 1) / dst_region_w) -
|
||||
(lin_ptr[x] << 1)) << 7;
|
||||
else if (dst_region_w > 65536)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 2) / dst_region_w) -
|
||||
(lin_ptr[x] << 2)) << 6;
|
||||
else if (dst_region_w > 37268)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 3) / dst_region_w) -
|
||||
(lin_ptr[x] << 3)) << 5;
|
||||
else if (dst_region_w > 16384)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 4) / dst_region_w) -
|
||||
(lin_ptr[x] << 4)) << 4;
|
||||
else if (dst_region_w > 8192)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 5) / dst_region_w) -
|
||||
(lin_ptr[x] << 5)) << 3;
|
||||
else if (dst_region_w > 4096)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 6) / dst_region_w) -
|
||||
(lin_ptr[x] << 6)) << 2;
|
||||
else if (dst_region_w > 2048)
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 7) / dst_region_w) -
|
||||
(lin_ptr[x] << 7)) << 1;
|
||||
else
|
||||
interp_x[x] = (((((x + dst_clip_x - dst_region_x) *
|
||||
(src_region_w)) << 8) / dst_region_w) -
|
||||
(lin_ptr[x] << 8));
|
||||
lin_ptr[x] += src_region_x;
|
||||
}
|
||||
else
|
||||
{
|
||||
lin_ptr[x] = (((x + dst_clip_x - dst_region_x) *
|
||||
src_region_w) / dst_region_w);
|
||||
interp_x[x] = 0;
|
||||
lin_ptr[x] += src_region_x;
|
||||
}
|
||||
}
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
int pos;
|
||||
|
||||
if (src_region_h > 1)
|
||||
{
|
||||
pos = (((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) / dst_region_h);
|
||||
row_ptr[y] = src_data + ((pos + src_region_y) * src_w);
|
||||
if (dst_region_h > 262144)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h))) / dst_region_h) -
|
||||
(pos)) << 8;
|
||||
else if (dst_region_h > 131072)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 1) / dst_region_h) -
|
||||
(pos << 1)) << 7;
|
||||
else if (dst_region_h > 65536)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 2) / dst_region_h) -
|
||||
(pos << 2)) << 6;
|
||||
else if (dst_region_h > 32768)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 3) / dst_region_h) -
|
||||
(pos << 3)) << 5;
|
||||
else if (dst_region_h > 16384)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 4) / dst_region_h) -
|
||||
(pos << 4)) << 4;
|
||||
else if (dst_region_h > 8192)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 5) / dst_region_h) -
|
||||
(pos << 5)) << 3;
|
||||
else if (dst_region_h > 4096)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 6) / dst_region_h) -
|
||||
(pos << 6)) << 2;
|
||||
else if (dst_region_h > 2048)
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 7) / dst_region_h) -
|
||||
(pos << 7)) << 1;
|
||||
else
|
||||
interp_y[y] = (((((y + dst_clip_y - dst_region_y) *
|
||||
(src_region_h)) << 8) / dst_region_h) -
|
||||
(pos << 8));
|
||||
}
|
||||
else
|
||||
{
|
||||
pos = (((y + dst_clip_y - dst_region_y) *
|
||||
src_region_h) / dst_region_h);
|
||||
row_ptr[y] = src_data + ((pos + src_region_y) * src_w);
|
||||
interp_y[y] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
dptr = dst_ptr;
|
||||
|
||||
#ifndef SCALE_USING_MMX
|
||||
if (src->flags & RGBA_IMAGE_HAS_ALPHA)
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
int i, j, k, l, px;
|
||||
DATA8 p1r, p1g, p1b, p1a;
|
||||
DATA8 p2r, p2g, p2b, p2a;
|
||||
DATA32 *lptr1, *lptr2;
|
||||
|
||||
p1r = p1g = p1b = p1a = 0;
|
||||
p2r = p2g = p2b = p2a = 0;
|
||||
|
||||
lptr1 = row_ptr[y];
|
||||
if ((lptr1 + src_w) >=
|
||||
(src->image->data +
|
||||
(src->image->w *
|
||||
src->image->h)))
|
||||
lptr2 = lptr1;
|
||||
else
|
||||
lptr2 = lptr1 + src_w;
|
||||
|
||||
k = interp_y[y];
|
||||
l = 256 - k;
|
||||
|
||||
dst_ptr = buf;
|
||||
|
||||
px = -1;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
i = interp_x[x];
|
||||
j = 256 - i;
|
||||
|
||||
if (px != lin_ptr[x])
|
||||
{
|
||||
px = lin_ptr[x];
|
||||
|
||||
ptr = lptr1 + lin_ptr[x];
|
||||
ptr3 = lptr2 + lin_ptr[x];
|
||||
if (lin_ptr[x] >= (src->image->w - 1))
|
||||
{
|
||||
ptr2 = ptr;
|
||||
ptr4 = ptr3;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr2 = ptr + 1;
|
||||
ptr4 = ptr3 + 1;
|
||||
}
|
||||
|
||||
if (A_VAL(ptr) |
|
||||
A_VAL(ptr2) |
|
||||
A_VAL(ptr3) |
|
||||
A_VAL(ptr4))
|
||||
{
|
||||
p1r = INTERP_2(R_VAL(ptr), R_VAL(ptr3), k, l);
|
||||
p1g = INTERP_2(G_VAL(ptr), G_VAL(ptr3), k, l);
|
||||
p1b = INTERP_2(B_VAL(ptr), B_VAL(ptr3), k, l);
|
||||
p1a = INTERP_2(A_VAL(ptr), A_VAL(ptr3), k, l);
|
||||
p2r = INTERP_2(R_VAL(ptr2), R_VAL(ptr4), k, l);
|
||||
p2g = INTERP_2(G_VAL(ptr2), G_VAL(ptr4), k, l);
|
||||
p2b = INTERP_2(B_VAL(ptr2), B_VAL(ptr4), k, l);
|
||||
p2a = INTERP_2(A_VAL(ptr2), A_VAL(ptr4), k, l);
|
||||
}
|
||||
else
|
||||
{
|
||||
p1a = 0;
|
||||
p2a = 0;
|
||||
}
|
||||
}
|
||||
if (p1a | p2a)
|
||||
{
|
||||
R_VAL(dst_ptr) = INTERP_2(p1r, p2r, i, j);
|
||||
G_VAL(dst_ptr) = INTERP_2(p1g, p2g, i, j);
|
||||
B_VAL(dst_ptr) = INTERP_2(p1b, p2b, i, j);
|
||||
A_VAL(dst_ptr) = INTERP_2(p1a, p2a, i, j);
|
||||
}
|
||||
else
|
||||
A_VAL(dst_ptr) = 0;
|
||||
|
||||
dst_ptr++;
|
||||
}
|
||||
/* * blend here [clip_w *] buf -> dptr * */
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
int i, j, k, l, px;
|
||||
DATA8 p1r, p1g, p1b;
|
||||
DATA8 p2r, p2g, p2b;
|
||||
DATA32 *lptr1, *lptr2;
|
||||
|
||||
p1r = p1g = p1b = 0;
|
||||
p2r = p2g = p2b = 0;
|
||||
|
||||
lptr1 = row_ptr[y];
|
||||
if ((lptr1 + src_w) >=
|
||||
(src->image->data +
|
||||
(src->image->w *
|
||||
src->image->h)))
|
||||
lptr2 = lptr1;
|
||||
else
|
||||
lptr2 = lptr1 + src_w;
|
||||
|
||||
k = interp_y[y];
|
||||
l = 256 - k;
|
||||
|
||||
dst_ptr = buf;
|
||||
|
||||
px = -1;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
i = interp_x[x];
|
||||
j = 256 - i;
|
||||
|
||||
if (px != lin_ptr[x])
|
||||
{
|
||||
px = lin_ptr[x];
|
||||
|
||||
ptr = lptr1 + lin_ptr[x];
|
||||
ptr3 = lptr2 + lin_ptr[x];
|
||||
if (lin_ptr[x] >= (src->image->w - 1))
|
||||
{
|
||||
ptr2 = ptr;
|
||||
ptr4 = ptr3;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr2 = ptr + 1;
|
||||
ptr4 = ptr3 + 1;
|
||||
}
|
||||
|
||||
p1r = INTERP_2(R_VAL(ptr), R_VAL(ptr3), k, l);
|
||||
p1g = INTERP_2(G_VAL(ptr), G_VAL(ptr3), k, l);
|
||||
p1b = INTERP_2(B_VAL(ptr), B_VAL(ptr3), k, l);
|
||||
p2r = INTERP_2(R_VAL(ptr2), R_VAL(ptr4), k, l);
|
||||
p2g = INTERP_2(G_VAL(ptr2), G_VAL(ptr4), k, l);
|
||||
p2b = INTERP_2(B_VAL(ptr2), B_VAL(ptr4), k, l);
|
||||
}
|
||||
R_VAL(dst_ptr) = INTERP_2(p1r, p2r, i, j);
|
||||
G_VAL(dst_ptr) = INTERP_2(p1g, p2g, i, j);
|
||||
B_VAL(dst_ptr) = INTERP_2(p1b, p2b, i, j);
|
||||
A_VAL(dst_ptr) = 0xff;
|
||||
|
||||
dst_ptr++;
|
||||
}
|
||||
/* * blend here [clip_w *] buf -> dptr * */
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
}
|
||||
#else
|
||||
pxor_r2r(mm7, mm7);
|
||||
for (y = 0; y < dst_clip_h; y++)
|
||||
{
|
||||
DATA32 *lptr1, *lptr2;
|
||||
int i, j, k, l, px;
|
||||
|
||||
lptr1 = row_ptr[y];
|
||||
if ((lptr1 + src_w) >=
|
||||
(src->image->data +
|
||||
(src->image->w *
|
||||
src->image->h)))
|
||||
lptr2 = lptr1;
|
||||
else
|
||||
lptr2 = lptr1 + src_w;
|
||||
|
||||
k = interp_y[y];
|
||||
l = 256 - k;
|
||||
|
||||
dst_ptr = buf;
|
||||
|
||||
/* mm5 = k */
|
||||
/* mm6 = l */
|
||||
movd_m2r(k, mm5);
|
||||
punpcklwd_r2r(mm5, mm5);
|
||||
punpckldq_r2r(mm5, mm5);
|
||||
movd_m2r(l, mm6);
|
||||
punpcklwd_r2r(mm6, mm6);
|
||||
punpckldq_r2r(mm6, mm6);
|
||||
|
||||
px = -1;
|
||||
|
||||
for (x = 0; x < dst_clip_w; x++)
|
||||
{
|
||||
i = interp_x[x];
|
||||
j = 256 - i;
|
||||
|
||||
/* if we have a new pair of horizontal pixels to */
|
||||
/* interpolate between them vertically */
|
||||
if (px != lin_ptr[x])
|
||||
{
|
||||
px = lin_ptr[x];
|
||||
|
||||
ptr = lptr1 + lin_ptr[x];
|
||||
ptr3 = lptr2 + lin_ptr[x];
|
||||
if (lin_ptr[x] >= (src->image->w - 1))
|
||||
{
|
||||
ptr2 = ptr;
|
||||
ptr4 = ptr3;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr2 = ptr + 1;
|
||||
ptr4 = ptr3 + 1;
|
||||
}
|
||||
|
||||
/* left edge */
|
||||
movd_m2r(ptr[0], mm0);
|
||||
punpcklbw_r2r(mm7, mm0);
|
||||
pmullw_r2r(mm6, mm0);
|
||||
|
||||
movd_m2r(ptr3[0], mm1);
|
||||
punpcklbw_r2r(mm7, mm1);
|
||||
pmullw_r2r(mm5, mm1);
|
||||
|
||||
paddw_r2r(mm1, mm0);
|
||||
psrlw_i2r(8, mm0);
|
||||
/* mm0 = left edge */
|
||||
|
||||
/* right edge */
|
||||
movd_m2r(ptr2[0], mm1);
|
||||
punpcklbw_r2r(mm7, mm1);
|
||||
pmullw_r2r(mm6, mm1);
|
||||
|
||||
movd_m2r(ptr4[0], mm2);
|
||||
punpcklbw_r2r(mm7, mm2);
|
||||
pmullw_r2r(mm5, mm2);
|
||||
|
||||
paddw_r2r(mm2, mm1);
|
||||
psrlw_i2r(8, mm1);
|
||||
/* mm1 = right edge */
|
||||
}
|
||||
|
||||
movq_r2r(mm1, mm4);
|
||||
|
||||
movd_m2r(i, mm2);
|
||||
punpcklwd_r2r(mm2, mm2);
|
||||
punpckldq_r2r(mm2, mm2);
|
||||
pmullw_r2r(mm2, mm4);
|
||||
|
||||
movq_r2r(mm0, mm3);
|
||||
|
||||
movd_m2r(j, mm2);
|
||||
punpcklwd_r2r(mm2, mm2);
|
||||
punpckldq_r2r(mm2, mm2);
|
||||
pmullw_r2r(mm2, mm3);
|
||||
|
||||
paddw_r2r(mm4, mm3);
|
||||
psrlw_i2r(8, mm3);
|
||||
|
||||
packuswb_r2r(mm3, mm3);
|
||||
/* blend mm3... */
|
||||
movd_r2m(mm3, dst_ptr[0]);
|
||||
|
||||
dst_ptr++;
|
||||
}
|
||||
/* * blend here [clip_w *] buf -> dptr * */
|
||||
if (dc->mod.use)
|
||||
func_cmod(buf, dptr, dst_clip_w, dc->mod.r, dc->mod.g, dc->mod.b, dc->mod.a);
|
||||
else if (dc->mul.use)
|
||||
func_mul(buf, dptr, dst_clip_w, dc->mul.col);
|
||||
else
|
||||
func(buf, dptr, dst_clip_w);
|
||||
dptr += dst_w;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -294,11 +294,6 @@ struct _RGBA_Image
|
|||
Evas_Object_List _list_data;
|
||||
RGBA_Surface *image;
|
||||
RGBA_Image_Flags flags;
|
||||
struct
|
||||
{
|
||||
int num;
|
||||
RGBA_Surface **levels;
|
||||
} mipmaps;
|
||||
struct
|
||||
{
|
||||
int format;
|
||||
|
|
@ -751,11 +746,6 @@ void evas_common_scale_rgb_mipmap_down_1x2_c (DATA32 *src, DATA32 *dst
|
|||
void evas_common_scale_rgba_mipmap_down_2x2_mmx (DATA32 *src, DATA32 *dst, int src_w, int src_h);
|
||||
void evas_common_scale_rgba_mipmap_down_2x1_mmx (DATA32 *src, DATA32 *dst, int src_w, int src_h);
|
||||
void evas_common_scale_rgba_mipmap_down_1x2_mmx (DATA32 *src, DATA32 *dst, int src_w, int src_h);
|
||||
|
||||
void evas_common_scale_rgba_gen_mipmap_table (RGBA_Image *src);
|
||||
void evas_common_scale_rgba_gen_mipmap_level (RGBA_Image *src, int l);
|
||||
int evas_common_scale_rgba_get_mipmap_surfaces (RGBA_Image *src, int src_region_w, int src_region_h, int dst_region_w, int dst_region_h, RGBA_Surface **srf1, RGBA_Surface **srf2);
|
||||
RGBA_Surface *evas_common_scale_rgba_get_mipmap_surface (RGBA_Image *src, int src_region_w, int src_region_h, int dst_region_w, int dst_region_h);
|
||||
|
||||
void evas_common_scale_rgba_in_to_out_clip_smooth_mmx (RGBA_Image *src, RGBA_Image *dst, RGBA_Draw_Context *dc, int src_region_x, int src_region_y, int src_region_w, int src_region_h, int dst_region_x, int dst_region_y, int dst_region_w, int dst_region_h);
|
||||
void evas_common_scale_rgba_in_to_out_clip_smooth_c (RGBA_Image *src, RGBA_Image *dst, RGBA_Draw_Context *dc, int src_region_x, int src_region_y, int src_region_w, int src_region_h, int dst_region_x, int dst_region_y, int dst_region_w, int dst_region_h);
|
||||
|
|
|
|||
Loading…
Reference in New Issue