enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

efl/evas/filters: say goodbye. 

This task wasn't completed and it was all disabled in code, then
remove it so it doesn't add cruft to be looked at.



SVN revision: 80240
This commit is contained in:
Gustavo Sverzut Barbieri 2012-12-05 13:03:51 +00:00
parent 625f6edd09
commit 545057d0b1
50 changed files with 0 additions and 2986 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/Makefile_Evas.am
View File

@ -45,7 +45,6 @@ lib/evas/canvas/evas_common_interface.c \
lib/evas/canvas/evas_data.c \
lib/evas/canvas/evas_device.c \
lib/evas/canvas/evas_events.c \
lib/evas/canvas/evas_filter.c \
lib/evas/canvas/evas_focus.c \
lib/evas/canvas/evas_key.c \
lib/evas/canvas/evas_key_grab.c \
@ -490,7 +489,6 @@ modules/evas/engines/gl_common/evas_gl_image.c \
modules/evas/engines/gl_common/evas_gl_font.c \
modules/evas/engines/gl_common/evas_gl_polygon.c \
modules/evas/engines/gl_common/evas_gl_line.c \
modules/evas/engines/gl_common/evas_gl_filter.c \
modules/evas/engines/gl_common/evas_gl_core.c \
modules/evas/engines/gl_common/evas_gl_api_ext.h \
modules/evas/engines/gl_common/evas_gl_api_ext_def.h \
@ -524,22 +522,6 @@ modules/evas/engines/gl_common/shader/tex_frag.h \
modules/evas/engines/gl_common/shader/tex_vert.h \
modules/evas/engines/gl_common/shader/tex_nomul_frag.h \
modules/evas/engines/gl_common/shader/tex_nomul_vert.h \
modules/evas/engines/gl_common/shader/filter_invert.h \
modules/evas/engines/gl_common/shader/filter_invert_nomul.h \
modules/evas/engines/gl_common/shader/filter_invert_bgra.h \
modules/evas/engines/gl_common/shader/filter_invert_bgra_nomul.h \
modules/evas/engines/gl_common/shader/filter_sepia.h \
modules/evas/engines/gl_common/shader/filter_sepia_nomul.h \
modules/evas/engines/gl_common/shader/filter_sepia_bgra.h \
modules/evas/engines/gl_common/shader/filter_sepia_bgra_nomul.h \
modules/evas/engines/gl_common/shader/filter_greyscale.h \
modules/evas/engines/gl_common/shader/filter_greyscale_nomul.h \
modules/evas/engines/gl_common/shader/filter_greyscale_bgra.h \
modules/evas/engines/gl_common/shader/filter_greyscale_bgra_nomul.h \
modules/evas/engines/gl_common/shader/filter_blur.h \
modules/evas/engines/gl_common/shader/filter_blur_nomul.h \
modules/evas/engines/gl_common/shader/filter_blur_bgra.h \
modules/evas/engines/gl_common/shader/filter_blur_bgra_nomul.h \
modules/evas/engines/gl_common/shader/yuy2_frag.h \
modules/evas/engines/gl_common/shader/yuy2_vert.h \
modules/evas/engines/gl_common/shader/yuy2_nomul_frag.h \
@ -570,22 +552,6 @@ modules/evas/engines/gl_common/shader/tex_frag.shd \
modules/evas/engines/gl_common/shader/tex_vert.shd \
modules/evas/engines/gl_common/shader/tex_nomul_frag.shd \
modules/evas/engines/gl_common/shader/tex_nomul_vert.shd \
modules/evas/engines/gl_common/shader/filter_invert.shd \
modules/evas/engines/gl_common/shader/filter_invert_nomul.shd \
modules/evas/engines/gl_common/shader/filter_invert_bgra.shd \
modules/evas/engines/gl_common/shader/filter_invert_bgra_nomul.shd \
modules/evas/engines/gl_common/shader/filter_greyscale.shd \
modules/evas/engines/gl_common/shader/filter_greyscale_nomul.shd \
modules/evas/engines/gl_common/shader/filter_greyscale_bgra.shd \
modules/evas/engines/gl_common/shader/filter_greyscale_bgra_nomul.shd \
modules/evas/engines/gl_common/shader/filter_sepia.shd \
modules/evas/engines/gl_common/shader/filter_sepia_nomul.shd \
modules/evas/engines/gl_common/shader/filter_sepia_bgra.shd \
modules/evas/engines/gl_common/shader/filter_sepia_bgra_nomul.shd \
modules/evas/engines/gl_common/shader/filter_blur.shd \
modules/evas/engines/gl_common/shader/filter_blur_nomul.shd \
modules/evas/engines/gl_common/shader/filter_blur_bgra.shd \
modules/evas/engines/gl_common/shader/filter_blur_bgra_nomul.shd \
modules/evas/engines/gl_common/shader/nv12_frag.h \
modules/evas/engines/gl_common/shader/nv12_frag.shd \
modules/evas/engines/gl_common/shader/nv12_nomul_frag.h \

1428
src/lib/evas/canvas/evas_filter.c
View File

File diff suppressed because it is too large Load Diff

209
src/lib/evas/canvas/evas_object_image.c
View File

@ -2873,158 +2873,6 @@ _proxy_subrender(Evas *eo_e, Evas_Object *eo_source)
*/
}
#if 0 // filtering disabled
/*
*
* Note that this is similar to proxy_subrender_recurse. It should be
* possible to merge I guess
*/
static void
image_filter_draw_under_recurse(Evas *eo_e, Evas_Object *eo_obj, Evas_Object *stop,
void *output, void *ctx, void *surface,
int x, int y)
{
Evas_Object *eo_obj2;
if (obj->clip.clipees) return;
/* FIXME: Doing bounding box test */
if (!evas_object_is_in_output_rect(eo_obj, stop->cur.geometry.x,
stop->cur.geometry.y,
stop->cur.geometry.w,
stop->cur.geometry.h))
return;
if (!evas_object_is_visible(eo_obj)) return;
obj->pre_render_done = 1;
ctx = e->engine.func->context_new(output);
if (obj->is_smart)
{
EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2)
{
if (obj2 == stop) return;
image_filter_draw_under_recurse(e, obj2, stop, output, surface,
ctx, x, y);
}
}
else
obj->func->render(eo_obj, output, ctx, surface, x ,y);
e->engine.func->context_free(output, ctx);
}
/*
* Draw all visible objects intersecting an object which are _beneath_ it.
*/
static void
image_filter_draw_under(Evas *eo_e, Evas_Object *stop, void *output, void *ctx, void *surface, int dx, int dy)
{
Evas_Layer *lay;
int x, y;
x = stop->cur.geometry.x - dx;
y = stop->cur.geometry.y - dy;
EINA_INLIST_FOREACH(e->layers, lay)
{
Evas_Object *eo_obj;
EINA_INLIST_FOREACH(lay->objects, obj)
{
if (obj->delete_me) continue;
if (obj == stop) return;
/* FIXME: Do bounding box check */
image_filter_draw_under_recurse(e, obj, stop, output, ctx,
surface, -x, -y);
}
}
e->engine.func->image_dirty_region(output, surface, 0, 0, 300, 300);
e->engine.func->output_flush(output);
}
/*
* Update the filtered object.
*
* Creates a new context, and renders stuff (filtered) onto that.
*/
Filtered_Image *
image_filter_update(Evas *eo_e, Evas_Object *eo_obj, void *src, int imagew, int imageh, int *outw, int *outh)
{
int w, h;
void *ctx;
Evas_Filter_Info *info;
void *surface;
Eina_Bool alpha;
info = obj->filter;
if (info->mode == EVAS_FILTER_MODE_BELOW)
{
w = obj->cur.geometry.w;
h = obj->cur.geometry.h;
evas_filter_get_size(info, w, h, &imagew, &imageh, EINA_TRUE);
alpha = EINA_FALSE;
}
else
{
evas_filter_get_size(info, imagew, imageh, &w, &h, EINA_FALSE);
alpha = e->engine.func->image_alpha_get(e->engine.data.output, src);
}
/* Certain filters may make alpha images anyway */
if (alpha == EINA_FALSE) alpha = evas_filter_always_alpha(info);
surface = e->engine.func->image_map_surface_new(e->engine.data.output, w, h,
alpha);
if (info->mode == EVAS_FILTER_MODE_BELOW)
{
void *subsurface;
int disw, dish;
int dx, dy;
disw = obj->cur.geometry.w;
dish = obj->cur.geometry.h;
dx = (imagew - w) >> 1;
dy = (imageh - h) >> 1;
subsurface = e->engine.func->image_map_surface_new
(e->engine.data.output, imagew, imageh, 1);
ctx = e->engine.func->context_new(e->engine.data.output);
e->engine.func->context_color_set(e->engine.data.output, ctx, 0, 255, 0, 255);
e->engine.func->context_render_op_set(e->engine.data.output, ctx, EVAS_RENDER_COPY);
e->engine.func->rectangle_draw(e->engine.data.output, ctx,
subsurface, 0, 0, imagew, imageh);
image_filter_draw_under(e, obj, e->engine.data.output, ctx,
subsurface, dx, dy);
e->engine.func->context_free(e->engine.data.output, ctx);
ctx = e->engine.func->context_new(e->engine.data.output);
e->engine.func->image_draw_filtered(e->engine.data.output,
ctx, surface, subsurface, info);
e->engine.func->context_free(e->engine.data.output, ctx);
e->engine.func->image_map_surface_free(e->engine.data.output,
subsurface);
}
else
{
ctx = e->engine.func->context_new(e->engine.data.output);
e->engine.func->image_draw_filtered(e->engine.data.output,
ctx, surface, src, info);
e->engine.func->context_free(e->engine.data.output, ctx);
}
e->engine.func->image_dirty_region(e->engine.data.output, surface,
0, 0, w, h);
if (outw) *outw = w;
if (outh) *outh = h;
return e->engine.func->image_filtered_save(src, surface,
obj->filter->key,
obj->filter->len);
}
#endif
static void
evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty)
{
@ -3365,57 +3213,6 @@ evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, v
o->proxyrendering = EINA_FALSE;
}
#if 0 // filtering disabled
/* Now check/update filter */
if (obj->filter && obj->filter->filter)
{
Filtered_Image *fi = NULL;
//printf("%p has filter: %s\n", obj,obj->filter->dirty?"dirty":"clean");
if (obj->filter->dirty)
{
if (obj->filter->mode != EVAS_FILTER_MODE_BELOW)
{
uint32_t len;
uint8_t *key;
if (obj->filter->key) free(obj->filter->key);
obj->filter->key = NULL;
obj->filter->len = 0;
key = evas_filter_key_get(obj->filter, &len);
if (key)
{
obj->filter->key = key;
obj->filter->len = len;
fi = obj->layer->evas->engine.func->image_filtered_get
(o->engine_data, key, len);
if (obj->filter->cached && fi != obj->filter->cached)
{
obj->layer->evas->engine.func->image_filtered_free
(o->engine_data, obj->filter->cached);
obj->filter->cached = NULL;
}
}
}
else if (obj->filter->cached)
{
obj->layer->evas->engine.func->image_filtered_free
(o->engine_data, obj->filter->cached);
}
if (!fi)
fi = image_filter_update(obj->layer->evas, obj, pixels,
imagew, imageh, &imagew, &imageh);
pixels = fi->image;
obj->filter->dirty = 0;
obj->filter->cached = fi;
}
else
{
fi = obj->filter->cached;
pixels = fi->image;
}
}
#endif
if (pixels)
{
Evas_Coord idw, idh, idx, idy;
@ -3944,12 +3741,6 @@ evas_object_image_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *ob
}
}
}
#if 0 // filtering disabled
if (obj->filter && obj->filter->dirty)
{
evas_object_render_pre_prev_cur_add(&e->clip_changes, obj);
}
#endif
/* it obviously didn't change - add a NO obscure - this "unupdates" this */
/* area so if there were updates for it they get wiped. don't do it if we */
/* aren't fully opaque and we are visible */

3
src/lib/evas/canvas/evas_object_main.c
View File

@ -88,9 +88,6 @@ evas_object_free(Evas_Object *eo_obj, int clean_layer)
int was_smart_child = 0;
#if 0 // filtering disabled
evas_filter_free(eo_obj);
#endif
if (!strcmp(obj->type, "image")) evas_object_image_video_surface_set(eo_obj, NULL);
evas_object_map_set(eo_obj, NULL);
if (obj->prev.map) evas_map_free(obj->prev.map);

13
src/lib/evas/common/evas_image_main.c
View File

@ -203,20 +203,7 @@ _evas_common_rgba_image_delete(Image_Entry *ie)
ie->file, ie->key);
// if (ie->data1) evas_cserve2_image_free(ie);
#endif
/*
* FIXME: This doesn't seem to be needed... But I'm not sure why.
* -- nash
{
Filtered_Image *fi;
EINA_LIST_FREE(im->filtered, fi)
{
free(fi->key);
_evas_common_rgba_image_delete((Image_Entry *)(fi->image));
free(fi);
}
}
*/
if (ie->frames)
{
Eina_List *l;

18
src/lib/evas/include/evas_common.h
View File

@ -487,10 +487,6 @@ typedef enum _Font_Rend_Flags
/*****************************************************************************/
#if 0 // filtering disabled
typedef struct _Filtered_Image Filtered_Image;
#endif
struct _RGBA_Image_Loadopts
{
int scale_down_by; // if > 1 then use this
@ -806,10 +802,6 @@ struct _RGBA_Image
Eina_Bool dirty: 1;
} mask;
#if 0 // filtering disabled
Eina_List *filtered;
#endif
struct {
LK(lock);
Eina_List *list;
@ -859,16 +851,6 @@ struct _RGBA_Map
RGBA_Map_Point pts[1];
};
#if 0 // filtering disabled
struct _Filtered_Image
{
void *key;
size_t keylen;
RGBA_Image *image;
int ref;
};
#endif
// for fonts...
/////
typedef struct _Fash_Item_Index_Map Fash_Item_Index_Map;

39
src/lib/evas/include/evas_private.h
View File

@ -487,35 +487,6 @@ struct _Evas_Map
Evas_Map_Point points[]; // actual points
};
#if 0 // filtering disabled
/* nash: Split into two bits */
typedef struct Evas_Filter_Info
{
Evas_Filter filter;
Evas_Filter_Mode mode;
Eina_Bool dirty : 1;
int datalen;
void *data;
void (*data_free)(void *);
uint8_t *key;
uint32_t len;
Filtered_Image *cached;
} Evas_Filter_Info;
typedef Eina_Bool (*Evas_Software_Filter_Fn)(Evas_Filter_Info *, RGBA_Image *, RGBA_Image *);
int evas_filter_get_size(Evas_Filter_Info *info, int inw, int inh,
int *outw, int *outh, Eina_Bool inv);
Eina_Bool evas_filter_always_alpha(Evas_Filter_Info *info);
uint8_t *evas_filter_key_get(const Evas_Filter_Info *info, uint32_t *lenp);
// expose for use in engines
EAPI Evas_Software_Filter_Fn evas_filter_software_get(Evas_Filter_Info *info);
void evas_filter_free(Evas_Object *o);
#endif
struct _Evas_Object_Protected_Data
{
EINA_INLIST;
@ -601,9 +572,6 @@ struct _Evas_Object_Protected_Data
// Pointer to the Evas_Object itself
Evas_Object *object;
#if 0 // filtering disabled
Evas_Filter_Info *filter;
#endif
Evas_Size_Hints *size_hints;
@ -903,13 +871,6 @@ struct _Evas_Func
Eina_Bool (*font_text_props_info_create) (void *data, Evas_Font_Instance *fi, const Eina_Unicode *text, Evas_Text_Props *intl_props, const Evas_BiDi_Paragraph_Props *par_props, size_t pos, size_t len, Evas_Text_Props_Mode mode);
int (*font_right_inset_get) (void *data, Evas_Font_Set *font, const Evas_Text_Props *text_props);
#if 0 // filtering disabled
void (*image_draw_filtered) (void *data, void *context, void *surface, void *image, Evas_Filter_Info *filter);
Filtered_Image *(*image_filtered_get) (void *image, uint8_t *key, size_t len);
Filtered_Image *(*image_filtered_save) (void *image, void *filtered, uint8_t *key, size_t len);
void (*image_filtered_free) (void *image, Filtered_Image *);
#endif
/* EFL-GL Glue Layer */
void *(*gl_surface_create) (void *data, void *config, int w, int h);
int (*gl_surface_destroy) (void *data, void *surface);

38
src/modules/evas/engines/gl_cocoa/evas_engine.c
View File

@ -564,40 +564,6 @@ eng_image_colorspace_set(void *data, void *image, int cspace)
// drivers?
//
//#define GLX_TEX_PIXMAP_RECREATE 1
#if 0
static void
eng_image_draw_filtered(void *data, void *context, void *surface,
void *image, Evas_Filter_Info *filter)
{
Render_Engine *re = data;
if (!image) return;
eng_window_use(re->win);
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
re->win->gl_context->dc = context;
evas_gl_common_filter_draw(re->win->gl_context, image, filter);
}
static Filtered_Image *
eng_image_filtered_get(void *im, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_get(im, key, keylen);
}
static Filtered_Image *
eng_image_filtered_save(void *im, void *fim, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_save(im, fim, key, keylen);
}
static void
eng_image_filtered_free(void *im, Filtered_Image *fim)
{
evas_gl_common_image_filtered_free(im, fim);
}
#endif
//
//
@ -1419,10 +1385,6 @@ module_open(Evas_Module *em)
ORD(image_mask_create);
// ORD(image_native_set);
// ORD(image_native_get);
// ORD(image_draw_filtered);
// ORD(image_filtered_get);
// ORD(image_filtered_save);
// ORD(image_filtered_free);
ORD(font_draw);

26
src/modules/evas/engines/gl_common/evas_gl_common.h
View File

@ -483,25 +483,6 @@ extern Evas_GL_Program_Source shader_tex_frag_src;
extern Evas_GL_Program_Source shader_tex_vert_src;
extern Evas_GL_Program_Source shader_tex_nomul_frag_src;
extern Evas_GL_Program_Source shader_tex_nomul_vert_src;
extern Evas_GL_Program_Source shader_filter_invert_frag_src;
extern Evas_GL_Program_Source shader_filter_invert_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_invert_bgra_frag_src;
extern Evas_GL_Program_Source shader_filter_invert_bgra_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_sepia_frag_src;
extern Evas_GL_Program_Source shader_filter_sepia_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_sepia_bgra_frag_src;
extern Evas_GL_Program_Source shader_filter_sepia_bgra_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_greyscale_frag_src;
extern Evas_GL_Program_Source shader_filter_greyscale_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_greyscale_bgra_frag_src;
extern Evas_GL_Program_Source shader_filter_greyscale_bgra_nomul_frag_src;
/* blur (annoyingly) needs (aka is faster with) a vertex shader */
extern Evas_GL_Program_Source shader_filter_blur_vert_src;
extern Evas_GL_Program_Source shader_filter_blur_frag_src;
extern Evas_GL_Program_Source shader_filter_blur_nomul_frag_src;
extern Evas_GL_Program_Source shader_filter_blur_bgra_frag_src;
extern Evas_GL_Program_Source shader_filter_blur_bgra_nomul_frag_src;
#endif
void glerr(int err, const char *file, const char *func, int line, const char *op);
@ -625,13 +606,6 @@ void evas_gl_common_poly_draw(Evas_Engine_GL_Context *gc, Evas_GL_P
void evas_gl_common_line_draw(Evas_Engine_GL_Context *gc, int x1, int y1, int x2, int y2);
#if 0 // filtering disabled
void evas_gl_common_filter_draw(Evas_Engine_GL_Context *context, Evas_GL_Image *im, Evas_Filter_Info *filter);
Filtered_Image *evas_gl_common_image_filtered_get(Evas_GL_Image *im, uint8_t *key, size_t keylen);
Filtered_Image *evas_gl_common_image_filtered_save(Evas_GL_Image *im, Evas_GL_Image *fimage, uint8_t *key, size_t keylen);
void evas_gl_common_image_filtered_free(Evas_GL_Image *im, Filtered_Image *);
#endif
extern void (*glsym_glGenFramebuffers) (GLsizei a, GLuint *b);
extern void (*glsym_glBindFramebuffer) (GLenum a, GLuint b);
extern void (*glsym_glFramebufferTexture2D) (GLenum a, GLenum b, GLenum c, GLuint d, GLint e);

181
src/modules/evas/engines/gl_common/evas_gl_filter.c
View File

@ -1,181 +0,0 @@
#include "evas_gl_private.h"
#if 0 // filtering disabled
void
evas_gl_common_filter_draw(Evas_Engine_GL_Context *gc, Evas_GL_Image *im, Evas_Filter_Info *filter)
{
RGBA_Draw_Context *dc;
GLuint prog;
int r,g,b,a;
int nomul, bgra;
dc = gc->dc;
if (dc->mul.use)
{
a = (dc->mul.col >> 24) & 0xff;
r = (dc->mul.col >> 16) & 0xff;
g = (dc->mul.col >> 8 ) & 0xff;
b = (dc->mul.col ) & 0xff;
}
else
{
r = g = b = a = 255;
}
nomul = (a == 255 && r == 255 && g == 255 && b == 255) ? 1 : 0;
bgra = (gc->shared->info.bgra) ? 1 : 0;
/* FIXME: This should so be a table */
#if 0
if (filter->filter == EVAS_FILTER_BLUR)
{
if (bgra)
{
if (nomul)
prog = gc->shared->shader.filter_blur_bgra_nomul.prog;
else
prog = gc->shared->shader.filter_blur_bgra.prog;
}
else
{
if (a == 255 && r == 255 && g == 255 && b == 255)
prog = gc->shared->shader.filter_blur_nomul.prog;
else
prog = gc->shared->shader.filter_blur.prog;
}
}
else
#endif
if (filter->filter == EVAS_FILTER_INVERT)
{
if (bgra)
{
if (nomul)
prog = gc->shared->shader.filter_invert_bgra_nomul.prog;
else
prog = gc->shared->shader.filter_invert_bgra.prog;
}
else
{
if (a == 255 && r == 255 && g == 255 && b == 255)
prog = gc->shared->shader.filter_invert_nomul.prog;
else
prog = gc->shared->shader.filter_invert.prog;
}
}
else if (filter->filter == EVAS_FILTER_SEPIA)
{
if (bgra)
{
if (nomul)
prog = gc->shared->shader.filter_sepia_bgra_nomul.prog;
else
prog = gc->shared->shader.filter_sepia_bgra.prog;
}
else
{
if (nomul)
prog = gc->shared->shader.filter_sepia_nomul.prog;
else
prog = gc->shared->shader.filter_sepia.prog;
}
}
else /*if (filter->filter == EVAS_FILTER_GREYSCALE)*/
{
printf("BGRA: %s Nomul: %s\n",bgra?"true":"false",nomul?"nomul":"mul");
if (bgra)
{
if (nomul)
prog = gc->shared->shader.filter_greyscale_bgra_nomul.prog;
else
prog = gc->shared->shader.filter_greyscale_bgra.prog;
}
else
{
if (nomul)
prog = gc->shared->shader.filter_greyscale_nomul.prog;
else
prog = gc->shared->shader.filter_greyscale.prog;
}
}
printf("Prog: %d %d %d\n",prog,im->w,im->h);
gc->filter_prog = prog;
evas_gl_common_image_update(gc, im);
evas_gl_common_context_image_push(gc, im->tex, 0, 0, im->w, im->h,
0, 0, im->w, im->h,
r,g,b,a,
1, im->tex_only);
gc->filter_prog = 0;
}
Filtered_Image *
evas_gl_common_image_filtered_get(Evas_GL_Image *im, uint8_t *key, size_t len)
{
Filtered_Image *fi;
Eina_List *l;
for (l = im->filtered ; l ; l = l->next)
{
fi = l->data;
if (fi->keylen != len) continue;
if (memcmp(key, fi->key, len) != 0) continue;
fi->ref ++;
return fi;
}
return NULL;
}
Filtered_Image *
evas_gl_common_image_filtered_save(Evas_GL_Image *im, Evas_GL_Image *fimage,
uint8_t *key, size_t keylen)
{
Filtered_Image *fi;
Eina_List *l;
for (l = im->filtered ; l ; l = l->next)
{
fi = l->data;
if (fi->keylen != keylen) continue;
if (memcmp(key, fi->key, keylen) != 0) continue;
fi->image = (void *)fimage;
fi->ref ++;
return fi;
}
fi = calloc(1,sizeof(Filtered_Image));
if (!fi) return NULL;
fi->keylen = keylen;
fi->key = malloc(keylen);
memcpy(fi->key, key, keylen);
fi->image = (void *)fimage;
fi->ref = 1;
im->filtered = eina_list_prepend(im->filtered, fi);
return fi;
}
void
evas_gl_common_image_filtered_free(Evas_GL_Image *image, Filtered_Image *fi)
{
fi->ref --;
if (fi->ref) return;
free(fi->key);
evas_gl_common_image_free((void *)fi->image);
fi->image = NULL;
image->filtered = eina_list_remove(image->filtered, fi);
}
#endif
/* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/

13
src/modules/evas/engines/gl_common/evas_gl_image.c
View File

@ -467,10 +467,6 @@ evas_gl_common_image_cache_flush(Evas_Engine_GL_Context *gc)
void
evas_gl_common_image_free(Evas_GL_Image *im)
{
#if 0 // filtering disabled
Filtered_Image *fi;
#endif
evas_gl_common_context_flush(im->gc);
im->references--;
if (im->references > 0) return;
@ -489,15 +485,6 @@ evas_gl_common_image_free(Evas_GL_Image *im)
if (im->im) evas_cache_image_drop(&im->im->cache_entry);
if (im->tex) evas_gl_common_texture_free(im->tex);
#if 0 // filtering disabled
EINA_LIST_FREE(im->filtered, fi)
{
free(fi->key);
evas_gl_common_image_free((Evas_GL_Image *)fi->image);
free(fi);
}
#endif
free(im);
}

178
src/modules/evas/engines/gl_common/evas_gl_shader.c
View File

@ -286,167 +286,6 @@ Evas_GL_Program_Source shader_img_bgra_nomul_vert_src =
NULL, 0
};
/////////////////////////////////////////////
const char filter_invert_frag_glsl[] =
#include "shader/filter_invert.h"
;
Evas_GL_Program_Source shader_filter_invert_frag_src =
{
filter_invert_frag_glsl,
NULL, 0
};
const char filter_invert_nomul_frag_glsl[] =
#include "shader/filter_invert_nomul.h"
;
Evas_GL_Program_Source shader_filter_invert_nomul_frag_src =
{
filter_invert_nomul_frag_glsl,
NULL, 0
};
const char filter_invert_bgra_frag_glsl[] =
#include "shader/filter_invert_bgra.h"
;
Evas_GL_Program_Source shader_filter_invert_bgra_frag_src =
{
filter_invert_bgra_frag_glsl,
NULL, 0
};
const char filter_invert_bgra_nomul_frag_glsl[] =
#include "shader/filter_invert_bgra_nomul.h"
;
Evas_GL_Program_Source shader_filter_invert_bgra_nomul_frag_src =
{
filter_invert_bgra_nomul_frag_glsl,
NULL, 0
};
/////////////////////////////////////////////
const char filter_greyscale_frag_glsl[] =
#include "shader/filter_greyscale.h"
;
Evas_GL_Program_Source shader_filter_greyscale_frag_src =
{
filter_greyscale_frag_glsl,
NULL, 0
};
const char filter_greyscale_nomul_frag_glsl[] =
#include "shader/filter_greyscale_nomul.h"
;
Evas_GL_Program_Source shader_filter_greyscale_nomul_frag_src =
{
filter_greyscale_nomul_frag_glsl,
NULL, 0
};
const char filter_greyscale_bgra_frag_glsl[] =
#include "shader/filter_greyscale_bgra.h"
;
Evas_GL_Program_Source shader_filter_greyscale_bgra_frag_src =
{
filter_greyscale_bgra_frag_glsl,
NULL, 0
};
const char filter_greyscale_bgra_nomul_frag_glsl[] =
#include "shader/filter_greyscale_bgra_nomul.h"
;
Evas_GL_Program_Source shader_filter_greyscale_bgra_nomul_frag_src =
{
filter_greyscale_bgra_nomul_frag_glsl,
NULL, 0
};
/////////////////////////////////////////////
const char filter_sepia_frag_glsl[] =
#include "shader/filter_sepia.h"
;
Evas_GL_Program_Source shader_filter_sepia_frag_src =
{
filter_sepia_frag_glsl,
NULL, 0
};
const char filter_sepia_nomul_frag_glsl[] =
#include "shader/filter_sepia_nomul.h"
;
Evas_GL_Program_Source shader_filter_sepia_nomul_frag_src =
{
filter_sepia_nomul_frag_glsl,
NULL, 0
};
const char filter_sepia_bgra_frag_glsl[] =
#include "shader/filter_sepia_bgra.h"
;
Evas_GL_Program_Source shader_filter_sepia_bgra_frag_src =
{
filter_sepia_bgra_frag_glsl,
NULL, 0
};
const char filter_sepia_bgra_nomul_frag_glsl[] =
#include "shader/filter_sepia_bgra_nomul.h"
;
Evas_GL_Program_Source shader_filter_sepia_bgra_nomul_frag_src =
{
filter_sepia_bgra_nomul_frag_glsl,
NULL, 0
};
/////////////////////////////////////////////
#if 0
Blur is a work in progress currently.
Mostly because GPUs are so hopeless.
const char filter_blur_vert_glsl[] =
#include "shader/filter_blur_vert.h"
;
Evas_GL_Program_Source shader_filter_blur_vert_src =
{
filter_blur_vert_glsl,
NULL, 0
};
const char filter_blur_frag_glsl[] =
#include "shader/filter_blur.h"
;
Evas_GL_Program_Source shader_filter_blur_frag_src =
{
filter_blur_frag_glsl,
NULL, 0
};
const char filter_blur_nomul_frag_glsl[] =
#include "shader/filter_blur_nomul.h"
;
Evas_GL_Program_Source shader_filter_blur_nomul_frag_src =
{
filter_blur_nomul_frag_glsl,
NULL, 0
};
const char filter_blur_bgra_frag_glsl[] =
#include "shader/filter_blur_bgra.h"
;
Evas_GL_Program_Source shader_filter_blur_bgra_frag_src =
{
filter_blur_bgra_frag_glsl,
NULL, 0
};
const char filter_blur_bgra_nomul_frag_glsl[] =
#include "shader/filter_blur_bgra_nomul.h"
;
Evas_GL_Program_Source shader_filter_blur_bgra_nomul_frag_src =
{
filter_blur_bgra_nomul_frag_glsl,
NULL, 0
};
#endif
/////////////////////////////////////////////
static void
@ -802,23 +641,6 @@ static const struct {
SHADER_SOURCE_LINE(NV12_NOMUL, nv12_nomul),
SHADER_SOURCE_LINE(TEX, tex),
SHADER_SOURCE_LINE(TEX_NOMUL, tex_nomul),
/* Most of the filters use the image fragment shader */
SHADER_SOURCE_FILTER_LINE(FILTER_INVERT, filter_invert),
SHADER_SOURCE_FILTER_LINE(FILTER_INVERT_NOMUL, filter_invert_nomul),
SHADER_SOURCE_FILTER_LINE(FILTER_INVERT_BGRA, filter_invert_bgra),
SHADER_SOURCE_FILTER_LINE(FILTER_INVERT_BGRA_NOMUL, filter_invert_bgra_nomul),
SHADER_SOURCE_FILTER_LINE(FILTER_GREYSCALE, filter_greyscale),
SHADER_SOURCE_FILTER_LINE(FILTER_GREYSCALE_NOMUL, filter_greyscale_nomul),
SHADER_SOURCE_FILTER_LINE(FILTER_GREYSCALE_BGRA, filter_greyscale_bgra),
SHADER_SOURCE_FILTER_LINE(FILTER_GREYSCALE_BGRA_NOMUL, filter_greyscale_bgra_nomul),
SHADER_SOURCE_FILTER_LINE(FILTER_SEPIA, filter_sepia),
SHADER_SOURCE_FILTER_LINE(FILTER_SEPIA_NOMUL, filter_sepia_nomul),
SHADER_SOURCE_FILTER_LINE(FILTER_SEPIA_BGRA, filter_sepia_bgra),
SHADER_SOURCE_FILTER_LINE(FILTER_SEPIA_BGRA_NOMUL, filter_sepia_bgra_nomul)/* , */
/* SHADER_SOURCE_LINE(FILTER_BLUR, filter_blur), */
/* SHADER_SOURCE_LINE(FILTER_BLUR_NOMUL, filter_blur_nomul), */
/* SHADER_SOURCE_LINE(FILTER_BLUR_BGRA, filter_blur_bgra), */
/* SHADER_SOURCE_LINE(FILTER_BLUR_BGRA_NOMUL, filter_blur_bgra_nomul) */
};
static int

24
src/modules/evas/engines/gl_common/shader/filter_blur.h
View File

@ -1,24 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"uniform sampler1D gaussian;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"varying weight;\n"
"uniform radius;\n"
"void main()\n"
"{\n"
" int i;\n"
" vec4 fc = vec4(0,0,0,0);\n"
" \n"
" for (i = 0 ; i < radius ; i ++){\n"
" fc += texture2D(tex, tex_c.xy).rgba *\n"
" texture1D(gaussian,i/radius).aaaa;\n"
" }\n"
" gl_FragColor = fc / 4 * col;\n"
"}\n"

24
src/modules/evas/engines/gl_common/shader/filter_blur.shd
View File

@ -1,24 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
uniform sampler1D gaussian;
varying vec4 col;
varying vec2 tex_c;
varying weight;
uniform radius;
void main()
{
int i;
vec4 fc = vec4(0,0,0,0);
for (i = 0 ; i < radius ; i ++){
fc += texture2D(tex, tex_c.xy).rgba *
texture1D(gaussian,i/radius).aaaa;
}
gl_FragColor = fc / 4 * col;
}

24
src/modules/evas/engines/gl_common/shader/filter_blur_bgra.h
View File

@ -1,24 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"uniform sampler1D gaussian;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"varying weight;\n"
"uniform radius;\n"
"void main()\n"
"{\n"
" int i;\n"
" vec4 fc = vec4(0,0,0,0);\n"
" \n"
" for (i = 0 ; i < radius ; i ++){\n"
" fc += texture2D(tex, tex_c.xy).rgba *\n"
" texture1D(gaussian,i/radius).aaaa;\n"
" }\n"
" gl_FragColor = fc / 4;\n"
"}\n"

24
src/modules/evas/engines/gl_common/shader/filter_blur_bgra.shd
View File

@ -1,24 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
uniform sampler1D gaussian;
varying vec4 col;
varying vec2 tex_c;
varying weight;
uniform radius;
void main()
{
int i;
vec4 fc = vec4(0,0,0,0);
for (i = 0 ; i < radius ; i ++){
fc += texture2D(tex, tex_c.xy).rgba *
texture1D(gaussian,i/radius).aaaa;
}
gl_FragColor = fc / 4;
}

24
src/modules/evas/engines/gl_common/shader/filter_blur_bgra_nomul.h
View File

@ -1,24 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"uniform sampler1D gaussian;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"varying weight;\n"
"uniform radius;\n"
"void main()\n"
"{\n"
" int i;\n"
" vec4 fc = vec4(0,0,0,0);\n"
" \n"
" for (i = 0 ; i < radius ; i ++){\n"
" fc += texture2D(tex, tex_c.xy).rgba *\n"
" texture1D(gaussian,i/radius).aaaa;\n"
" }\n"
" gl_FragColor = fc / 4;\n"
"}\n"

24
src/modules/evas/engines/gl_common/shader/filter_blur_bgra_nomul.shd
View File

@ -1,24 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
uniform sampler1D gaussian;
varying vec4 col;
varying vec2 tex_c;
varying weight;
uniform radius;
void main()
{
int i;
vec4 fc = vec4(0,0,0,0);
for (i = 0 ; i < radius ; i ++){
fc += texture2D(tex, tex_c.xy).rgba *
texture1D(gaussian,i/radius).aaaa;
}
gl_FragColor = fc / 4;
}

24
src/modules/evas/engines/gl_common/shader/filter_blur_nomul.h
View File

@ -1,24 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"uniform sampler1D gaussian;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"varying weight;\n"
"uniform radius;\n"
"void main()\n"
"{\n"
" int i;\n"
" vec4 fc = vec4(0,0,0,0);\n"
" \n"
" for (i = 0 ; i < radius ; i ++){\n"
" fc += texture2D(tex, tex_c.xy).rgba *\n"
" texture1D(gaussian,i/radius).aaaa;\n"
" }\n"
" gl_FragColor = fc / 4;\n"
"}\n"

24
src/modules/evas/engines/gl_common/shader/filter_blur_nomul.shd
View File

@ -1,24 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
uniform sampler1D gaussian;
varying vec4 col;
varying vec2 tex_c;
varying weight;
uniform radius;
void main()
{
int i;
vec4 fc = vec4(0,0,0,0);
for (i = 0 ; i < radius ; i ++){
fc += texture2D(tex, tex_c.xy).rgba *
texture1D(gaussian,i/radius).aaaa;
}
gl_FragColor = fc / 4;
}

29
src/modules/evas/engines/gl_common/shader/filter_blur_vert.h
View File

@ -1,29 +0,0 @@
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"attribute vec4 vertex;\n"
"attribute vec4 color;\n"
"attribute vec2 tex_coord;\n"
"attribute float r;\n"
"uniform mat4 mvp;\n"
"uniform sampler1D tex_blur;\n"
"varying float weight;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"\n"
"void main(){\n"
" /* FIXME: This index should be tweaked so for \n"
" radius 1, I want 3 points at 1/4, 2/4, 3/4 */\n"
" /*\n"
" for (float i = 0 ; i <= radius * 2 ; i ++){\n"
" float pos = i;\n"
" float r = float(radius);\n"
" weight += sampler1D(tex_blur, 1.0 / (r * 2.0 * pos));\n"
" }*/\n"
" for (float i = 0.0 ; i < r * 2.0 ; i += 1.0){\n"
" weight += sampler1D(tex_blur, 1.0 / (r * 2.0 * i));\n"
" }\n"
" gl_Position = mvp * vertex;\n"
" col = color;\n"
" tex_c = tex_coord;\n"
"}\n"

29
src/modules/evas/engines/gl_common/shader/filter_blur_vert.shd
View File

@ -1,29 +0,0 @@
#ifdef GL_ES
precision highp float;
#endif
attribute vec4 vertex;
attribute vec4 color;
attribute vec2 tex_coord;
attribute float r;
uniform mat4 mvp;
uniform sampler1D tex_blur;
varying float weight;
varying vec4 col;
varying vec2 tex_c;
void main(){
/* FIXME: This index should be tweaked so for
radius 1, I want 3 points at 1/4, 2/4, 3/4 */
/*
for (float i = 0 ; i <= radius * 2 ; i ++){
float pos = i;
float r = float(radius);
weight += sampler1D(tex_blur, 1.0 / (r * 2.0 * pos));
}*/
for (float i = 0.0 ; i < r * 2.0 ; i += 1.0){
weight += sampler1D(tex_blur, 1.0 / (r * 2.0 * i));
}
gl_Position = mvp * vertex;
col = color;
tex_c = tex_coord;
}

15
src/modules/evas/engines/gl_common/shader/filter_greyscale.h
View File

@ -1,15 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" float inten = dot(texture2D(tex,tex_c.xy).agb,vec3(.3, .59, .11));\n"
" gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).r) * col;\n"
"}\n"

15
src/modules/evas/engines/gl_common/shader/filter_greyscale.shd
View File

@ -1,15 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
float inten = dot(texture2D(tex,tex_c.xy).agb,vec3(.3, .59, .11));
gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).r) * col;
}

15
src/modules/evas/engines/gl_common/shader/filter_greyscale_bgra.h
View File

@ -1,15 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" float inten = dot(texture2D(tex,tex_c.xy).rgb,vec3(.3, .59, .11));\n"
" gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).a) * col;\n"
"}\n"

15
src/modules/evas/engines/gl_common/shader/filter_greyscale_bgra.shd
View File

@ -1,15 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
float inten = dot(texture2D(tex,tex_c.xy).rgb,vec3(.3, .59, .11));
gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).a) * col;
}

14
src/modules/evas/engines/gl_common/shader/filter_greyscale_bgra_nomul.h
View File

@ -1,14 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" float inten = dot(texture2D(tex,tex_c.xy).rgb,vec3(.3, .59, .11));\n"
" gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).a);\n"
"}\n"

14
src/modules/evas/engines/gl_common/shader/filter_greyscale_bgra_nomul.shd
View File

@ -1,14 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec2 tex_c;
void main()
{
float inten = dot(texture2D(tex,tex_c.xy).rgb,vec3(.3, .59, .11));
gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).a);
}

14
src/modules/evas/engines/gl_common/shader/filter_greyscale_nomul.h
View File

@ -1,14 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" float inten = dot(texture2D(tex,tex_c.xy).abg,vec3(.3, .59, .11));\n"
" gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).r);\n"
"}\n"

14
src/modules/evas/engines/gl_common/shader/filter_greyscale_nomul.shd
View File

@ -1,14 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec2 tex_c;
void main()
{
float inten = dot(texture2D(tex,tex_c.xy).abg,vec3(.3, .59, .11));
gl_FragColor = vec4(inten, inten, inten, texture2D(tex,tex_c.xy).r);
}

14
src/modules/evas/engines/gl_common/shader/filter_invert.h
View File

@ -1,14 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" gl_FragColor = (vec4(0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy).bgra)*col;\n"
"}\n"

14
src/modules/evas/engines/gl_common/shader/filter_invert.shd
View File

@ -1,14 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
gl_FragColor = (vec4(0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy).bgra)*col;
}

14
src/modules/evas/engines/gl_common/shader/filter_invert_bgra.h
View File

@ -1,14 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" gl_FragColor = (vec4(1.0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy))*col;\n"
"}\n"

14
src/modules/evas/engines/gl_common/shader/filter_invert_bgra.shd
View File

@ -1,14 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
gl_FragColor = (vec4(1.0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy))*col;
}

15
src/modules/evas/engines/gl_common/shader/filter_invert_bgra_nomul.h
View File

@ -1,15 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" vec3 inv = vec3(1.0, 1.0, 1.0) - texture2D(tex,tex_c.xy).rgb;\n"
" gl_FragColor = vec4(inv.r, inv.g, inv.b, 1.0);\n"
"}\n"

15
src/modules/evas/engines/gl_common/shader/filter_invert_bgra_nomul.shd
View File

@ -1,15 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
vec3 inv = vec3(1.0, 1.0, 1.0) - texture2D(tex,tex_c.xy).rgb;
gl_FragColor = vec4(inv.r, inv.g, inv.b, 1.0);
}

14
src/modules/evas/engines/gl_common/shader/filter_invert_nomul.h
View File

@ -1,14 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" gl_FragColor = (vec4(0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy).bgra)*col;\n"
"}\n"

14
src/modules/evas/engines/gl_common/shader/filter_invert_nomul.shd
View File

@ -1,14 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
gl_FragColor = (vec4(0, 1.0, 1.0, 1.0) - texture2D(tex, tex_c.xy).bgra)*col;
}

20
src/modules/evas/engines/gl_common/shader/filter_sepia.h
View File

@ -1,20 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" vec3 inp = texture2D(tex,tex_c.xy).abg;\n"
" vec4 sep;\n"
" sep.r = dot(inp, vec3(.393, .769, .189));\n"
" sep.g = dot(inp, vec3(.349, .686, .168));\n"
" sep.b = dot(inp, vec3(.272, .534, .131));\n"
" sep.a = texture2D(tex,tex_c.xy).r;\n"
" gl_FragColor = sep * col;\n"
"}\n"

20
src/modules/evas/engines/gl_common/shader/filter_sepia.shd
View File

@ -1,20 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
vec3 inp = texture2D(tex,tex_c.xy).abg;
vec4 sep;
sep.r = dot(inp, vec3(.393, .769, .189));
sep.g = dot(inp, vec3(.349, .686, .168));
sep.b = dot(inp, vec3(.272, .534, .131));
sep.a = texture2D(tex,tex_c.xy).r;
gl_FragColor = sep * col;
}

20
src/modules/evas/engines/gl_common/shader/filter_sepia_bgra.h
View File

@ -1,20 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" vec3 inp = texture2D(tex,tex_c.xy).rgb;\n"
" vec4 sep;\n"
" sep.r = dot(inp, vec3(.393, .769, .189));\n"
" sep.g = dot(inp, vec3(.349, .686, .168));\n"
" sep.b = dot(inp, vec3(.272, .534, .131));\n"
" sep.a = texture2D(tex,tex_c.xy).a;\n"
" gl_FragColor = sep * col;\n"
"}\n"

20
src/modules/evas/engines/gl_common/shader/filter_sepia_bgra.shd
View File

@ -1,20 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
vec3 inp = texture2D(tex,tex_c.xy).rgb;
vec4 sep;
sep.r = dot(inp, vec3(.393, .769, .189));
sep.g = dot(inp, vec3(.349, .686, .168));
sep.b = dot(inp, vec3(.272, .534, .131));
sep.a = texture2D(tex,tex_c.xy).a;
gl_FragColor = sep * col;
}

18
src/modules/evas/engines/gl_common/shader/filter_sepia_bgra_nomul.h
View File

@ -1,18 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" vec3 inp = texture2D(tex,tex_c.xy).rgb;\n"
" gl_FragColor.r = dot(inp, vec3(.393, .769, .189));\n"
" gl_FragColor.g = dot(inp, vec3(.349, .686, .168));\n"
" gl_FragColor.b = dot(inp, vec3(.272, .534, .131));\n"
" gl_FragColor.a = texture2D(tex,tex_c.xy).a;\n"
"}\n"

18
src/modules/evas/engines/gl_common/shader/filter_sepia_bgra_nomul.shd
View File

@ -1,18 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
vec3 inp = texture2D(tex,tex_c.xy).rgb;
gl_FragColor.r = dot(inp, vec3(.393, .769, .189));
gl_FragColor.g = dot(inp, vec3(.349, .686, .168));
gl_FragColor.b = dot(inp, vec3(.272, .534, .131));
gl_FragColor.a = texture2D(tex,tex_c.xy).a;
}

18
src/modules/evas/engines/gl_common/shader/filter_sepia_nomul.h
View File

@ -1,18 +0,0 @@
"#ifdef GL_ES\n"
"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
"#else\n"
"precision mediump float;\n"
"#endif\n"
"#endif\n"
"uniform sampler2D tex;\n"
"varying vec4 col;\n"
"varying vec2 tex_c;\n"
"void main()\n"
"{\n"
" vec3 inp = texture2D(tex,tex_c.xy).abg;\n"
" gl_FragColor.r = dot(inp, vec3(.393, .769, .189));\n"
" gl_FragColor.g = dot(inp, vec3(.349, .686, .168));\n"
" gl_FragColor.b = dot(inp, vec3(.272, .534, .131));\n"
" gl_FragColor.a = texture2D(tex,tex_c.xy).r;\n"
"}\n"

18
src/modules/evas/engines/gl_common/shader/filter_sepia_nomul.shd
View File

@ -1,18 +0,0 @@
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif
uniform sampler2D tex;
varying vec4 col;
varying vec2 tex_c;
void main()
{
vec3 inp = texture2D(tex,tex_c.xy).abg;
gl_FragColor.r = dot(inp, vec3(.393, .769, .189));
gl_FragColor.g = dot(inp, vec3(.349, .686, .168));
gl_FragColor.b = dot(inp, vec3(.272, .534, .131));
gl_FragColor.a = texture2D(tex,tex_c.xy).r;
}

6
src/modules/evas/engines/gl_sdl/evas_engine.c
View File

@ -1010,12 +1010,6 @@ module_open(Evas_Module *em)
ORD(image_colorspace_get);
ORD(image_native_set);
ORD(image_native_get);
#if 0 // filtering disabled
// ORD(image_draw_filtered);
// ORD(image_filtered_get);
// ORD(image_filtered_save);
// ORD(image_filtered_free);
#endif
ORD(font_draw);
ORD(image_scale_hint_set);

40
src/modules/evas/engines/gl_x11/evas_engine.c
View File

@ -2097,40 +2097,6 @@ eng_image_native_get(void *data EINA_UNUSED, void *image)
return &(n->ns);
}
#if 0 // filtering disabled
static void
eng_image_draw_filtered(void *data, void *context, void *surface,
void *image, Evas_Filter_Info *filter)
{
Render_Engine *re = data;
if (!image) return;
eng_window_use(re->win);
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
re->win->gl_context->dc = context;
evas_gl_common_filter_draw(re->win->gl_context, image, filter);
}
static Filtered_Image *
eng_image_filtered_get(void *im, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_get(im, key, keylen);
}
static Filtered_Image *
eng_image_filtered_save(void *im, void *fim, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_save(im, fim, key, keylen);
}
static void
eng_image_filtered_free(void *im, Filtered_Image *fim)
{
evas_gl_common_image_filtered_free(im, fim);
}
#endif
//
//
@ -2978,12 +2944,6 @@ module_open(Evas_Module *em)
ORD(image_mask_create);
ORD(image_native_set);
ORD(image_native_get);
#if 0 // filtering disabled
ORD(image_draw_filtered);
ORD(image_filtered_get);
ORD(image_filtered_save);
ORD(image_filtered_free);
#endif
ORD(font_draw);

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

@ -1366,88 +1366,6 @@ eng_canvas_alpha_get(void *data EINA_UNUSED, void *info EINA_UNUSED)
}
/* Filter API */
#if 0 // filtering disabled
static void
eng_image_draw_filtered(void *data EINA_UNUSED, void *context EINA_UNUSED,
void *surface, void *image, Evas_Filter_Info *filter)
{
Evas_Software_Filter_Fn fn;
RGBA_Image *im = image;
fn = evas_filter_software_get(filter);
if (!fn) return;
if (im->cache_entry.cache) evas_cache_image_load_data(&im->cache_entry);
fn(filter, image, surface);
return;
}
static Filtered_Image *
eng_image_filtered_get(void *image, uint8_t *key, size_t keylen)
{
RGBA_Image *im = image;
Filtered_Image *fi;
Eina_List *l;
for (l = im->filtered ; l ; l = l->next)
{
fi = l->data;
if (fi->keylen != keylen) continue;
if (memcmp(key, fi->key, keylen) != 0) continue;
fi->ref ++;
return fi;
}
return NULL;
}
static Filtered_Image *
eng_image_filtered_save(void *image, void *fimage, uint8_t *key, size_t keylen)
{
RGBA_Image *im = image;
Filtered_Image *fi;
Eina_List *l;
for (l = im->filtered ; l ; l = l->next)
{
fi = l->data;
if (fi->keylen != keylen) continue;
if (memcmp(key, fi->key, keylen) == 0) continue;
evas_cache_image_drop((void *)fi->image);
fi->image = fimage;
return fi;
}
fi = calloc(1,sizeof(Filtered_Image));
if (!fi) return NULL;
fi->keylen = keylen;
fi->key = malloc(keylen);
memcpy(fi->key, key, keylen);
fi->image = fimage;
fi->ref = 1;
im->filtered = eina_list_prepend(im->filtered, fi);
return fi;
}
static void
eng_image_filtered_free(void *image, Filtered_Image *fi)
{
RGBA_Image *im = image;
fi->ref --;
if (fi->ref) return;
free(fi->key);
evas_cache_image_drop(&fi->image->cache_entry);
fi->image = NULL;
im->filtered = eina_list_remove(im->filtered, fi);
}
#endif
static int
eng_image_load_error_get(void *data EINA_UNUSED, void *image)
{
@ -1885,12 +1803,6 @@ static Evas_Func func =
eng_font_pen_coords_get,
eng_font_text_props_info_create,
eng_font_right_inset_get,
#if 0 // filtering disabled
eng_image_draw_filtered,
eng_image_filtered_get,
eng_image_filtered_save,
eng_image_filtered_free,
#endif
NULL, // need software mesa for gl rendering <- gl_surface_create
NULL, // need software mesa for gl rendering <- gl_surface_destroy
NULL, // need software mesa for gl rendering <- gl_context_create

40
src/modules/evas/engines/wayland_egl/evas_engine.c
View File

@ -1563,40 +1563,6 @@ eng_image_native_get(void *data EINA_UNUSED, void *image)
return &(n->ns);
}
#if 0 // filtering disabled
static void
eng_image_draw_filtered(void *data, void *context, void *surface,
void *image, Evas_Filter_Info *filter)
{
Render_Engine *re = data;
if (!image) return;
eng_window_use(re->win);
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
re->win->gl_context->dc = context;
evas_gl_common_filter_draw(re->win->gl_context, image, filter);
}
static Filtered_Image *
eng_image_filtered_get(void *im, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_get(im, key, keylen);
}
static Filtered_Image *
eng_image_filtered_save(void *im, void *fim, uint8_t *key, size_t keylen)
{
return evas_gl_common_image_filtered_save(im, fim, key, keylen);
}
static void
eng_image_filtered_free(void *im, Filtered_Image *fim)
{
evas_gl_common_image_filtered_free(im, fim);
}
#endif
static void *
eng_image_load(void *data, const char *file, const char *key, int *error, Evas_Image_Load_Opts *lo)
{
@ -3776,12 +3742,6 @@ module_open(Evas_Module *em)
ORD(image_mask_create);
ORD(image_native_set);
ORD(image_native_get);
#if 0 // filtering disabled
ORD(image_draw_filtered);
ORD(image_filtered_get);
ORD(image_filtered_save);
ORD(image_filtered_free);
#endif
ORD(font_draw);