Hmmm, you did not port this change to wayland_egl ?? dh
On 06/24/13 04:04, Cedric Bail - Enlightenment Git wrote: > cedric pushed a commit to branch master. > > commit d06a0982ef3d156059b2264d4494e036cbe409ee > Author: Cedric Bail <cedric.b...@samsung.com> > Date: Mon Jun 24 11:41:32 2013 +0900 > > evas: add support for asynchronously uploading GL texture. > > NOTE: when using Evas_Object image preload infrastructure the GL texture > upload was uploaded from the main loop during the rendering stage. This > could lead to some frame drop during fast animation due to the time > needed > to upload that texture. > > This patch fix this problem by uploading a small texture quickly (16x16) > and waiting for going back to the main loop to be able to use the same GL > context from another thread to do the texture upload asynchronously > without > blocking the main loop. > --- > ChangeLog | 4 + > NEWS | 1 + > src/Makefile_Evas.am | 1 + > src/lib/evas/cache/evas_cache_image.c | 1 + > src/lib/evas/include/evas_common_private.h | 2 + > .../evas/engines/gl_common/evas_gl_common.h | 40 +- > .../evas/engines/gl_common/evas_gl_context.c | 54 ++- > src/modules/evas/engines/gl_common/evas_gl_core.c | 1 - > src/modules/evas/engines/gl_common/evas_gl_image.c | 5 +- > .../evas/engines/gl_common/evas_gl_preload.c | 441 > +++++++++++++++++++++ > .../evas/engines/gl_common/evas_gl_texture.c | 111 +++++- > src/modules/evas/engines/gl_x11/evas_engine.c | 72 +++- > src/modules/evas/engines/gl_x11/evas_x_main.c | 46 +++ > 13 files changed, 741 insertions(+), 38 deletions(-) > > diff --git a/ChangeLog b/ChangeLog > index 783c42e..d2abf99 100644 > --- a/ChangeLog > +++ b/ChangeLog > @@ -1,3 +1,7 @@ > +2013-06-24 Cedric Bail > + > + * Evas: add support for asynchronously uploading GL texture. > + > 2013-06-22 Thiep Ha > > * Edje: Move cursor to correct position when selection handlers are > pressed. > diff --git a/NEWS b/NEWS > index 9da4640..cd6dda8 100644 > --- a/NEWS > +++ b/NEWS > @@ -48,6 +48,7 @@ Additions: > - Add multiple font draws support to engines > - Add Cserve2 scalecache support > - Add evas_object_image_source_clip_set()/get() > + - Asynchronous preload of GL texture. > * ecore_x: > - Add window profile support. > ECORE_X_ATOM_E_WINDOW_PROFILE_SUPPORTED > diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am > index 7cc9433..d4fe9aa 100644 > --- a/src/Makefile_Evas.am > +++ b/src/Makefile_Evas.am > @@ -438,6 +438,7 @@ modules/evas/engines/gl_common/evas_gl_file_cache.c \ > modules/evas/engines/gl_common/evas_gl_shader.c \ > modules/evas/engines/gl_common/evas_gl_rectangle.c \ > modules/evas/engines/gl_common/evas_gl_texture.c \ > +modules/evas/engines/gl_common/evas_gl_preload.c \ > 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 \ > diff --git a/src/lib/evas/cache/evas_cache_image.c > b/src/lib/evas/cache/evas_cache_image.c > index fe779a5..06d74de 100644 > --- a/src/lib/evas/cache/evas_cache_image.c > +++ b/src/lib/evas/cache/evas_cache_image.c > @@ -396,6 +396,7 @@ _evas_cache_image_async_end(void *data) > ie->cache->pending = eina_list_remove(ie->cache->pending, ie); > ie->preload = NULL; > ie->flags.preload_done = ie->flags.loaded; > + ie->flags.updated_data = 1; > while ((tmp = ie->targets)) > { > evas_object_inform_call_image_preloaded((Evas_Object*) tmp->target); > diff --git a/src/lib/evas/include/evas_common_private.h > b/src/lib/evas/include/evas_common_private.h > index 1a3c10c..f051a72 100644 > --- a/src/lib/evas/include/evas_common_private.h > +++ b/src/lib/evas/include/evas_common_private.h > @@ -519,6 +519,8 @@ struct _Image_Entry_Flags > Eina_Bool rotated : 1; > Eina_Bool unload_cancel : 1; > Eina_Bool given_mmap : 1; > + > + Eina_Bool updated_data : 1; > }; > > struct _Image_Entry_Frame > diff --git a/src/modules/evas/engines/gl_common/evas_gl_common.h > b/src/modules/evas/engines/gl_common/evas_gl_common.h > index 8dc08ae..f0f3bd1 100644 > --- a/src/modules/evas/engines/gl_common/evas_gl_common.h > +++ b/src/modules/evas/engines/gl_common/evas_gl_common.h > @@ -162,6 +162,8 @@ > #define GL_MULTISAMPLE_BUFFER_BIT7_QCOM 0x80000000 > #endif > > +#define EVAS_GL_TILE_SIZE 16 > + > #define SHAD_VERTEX 0 > #define SHAD_COLOR 1 > #define SHAD_TEXUV 2 > @@ -181,6 +183,9 @@ typedef struct _Evas_GL_Image > Evas_GL_Image; > typedef struct _Evas_GL_Font_Texture Evas_GL_Font_Texture; > typedef struct _Evas_GL_Polygon Evas_GL_Polygon; > typedef struct _Evas_GL_Polygon_Point Evas_GL_Polygon_Point; > +typedef struct _Evas_GL_Texture_Async_Preload Evas_GL_Texture_Async_Preload; > + > +typedef Eina_Bool (*evas_gl_make_current_cb)(void *engine_data, void *doit); > > typedef enum { > SHADER_RECT, > @@ -494,6 +499,7 @@ struct _Evas_GL_Texture > Evas_GL_Texture_Alloca *apt, *aptt; > RGBA_Font_Glyph *fglyph; > int x, y, w, h; > + int tx, ty; > double sx1, sy1, sx2, sy2; > int references; > > @@ -503,8 +509,12 @@ struct _Evas_GL_Texture > int source; > } double_buffer; > > + Eina_List *targets; > + > Eina_Bool alpha : 1; > Eina_Bool dyn : 1; > + Eina_Bool uploaded : 1; > + Eina_Bool was_preloaded : 1; > }; > > struct _Evas_GL_Image > @@ -540,6 +550,7 @@ struct _Evas_GL_Image > int csize; > > Eina_List *filtered; > + Eina_List *targets; > > unsigned char dirty : 1; > unsigned char cached : 1; > @@ -563,6 +574,14 @@ struct _Evas_GL_Polygon_Point > int x, y; > }; > > +struct _Evas_GL_Texture_Async_Preload > +{ > + Evas_GL_Texture *tex; > + RGBA_Image *im; > + > + Eina_Bool unpack_row_length; > +}; > + > #if 0 > extern Evas_GL_Program_Source shader_rect_frag_src; > extern Evas_GL_Program_Source shader_rect_vert_src; > @@ -748,7 +767,19 @@ extern unsigned int (*secsym_eglUnmapImageSEC) > (void *a, void *b, > extern unsigned int (*secsym_eglGetImageAttribSEC) (void *a, void > *b, int c, int *d); > #endif > > -//#define GL_ERRORS 1 > +Eina_Bool evas_gl_preload_push(Evas_GL_Texture_Async_Preload *async); > +void evas_gl_preload_pop(Evas_GL_Texture *tex); > +int evas_gl_preload_init(void); > +int evas_gl_preload_shutdown(void); > +void evas_gl_preload_render_lock(evas_gl_make_current_cb make_current, void > *engine_data); > +void evas_gl_preload_render_unlock(evas_gl_make_current_cb make_current, > void *engine_data); > +void evas_gl_preload_render_relax(evas_gl_make_current_cb make_current, void > *engine_data); > +void evas_gl_preload_target_register(Evas_GL_Texture *tex, Eo *target); > +void evas_gl_preload_target_unregister(Evas_GL_Texture *tex, Eo *target); > + > +void pt_unref(Evas_GL_Texture_Pool *pt); > + > +#define GL_ERRORS 1 > > #ifdef GL_ERRORS > # define GLERR(fn, fl, ln, op) \ > @@ -763,4 +794,11 @@ extern unsigned int (*secsym_eglGetImageAttribSEC) > (void *a, void *b, > Eina_Bool evas_gl_common_module_open(void); > void evas_gl_common_module_close(void); > > +static inline void > +_tex_sub_2d(int x, int y, int w, int h, int fmt, int type, const void *pix) > +{ > + glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, fmt, type, pix); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > +} > + > #endif > diff --git a/src/modules/evas/engines/gl_common/evas_gl_context.c > b/src/modules/evas/engines/gl_common/evas_gl_context.c > index f99be54..1bdfac3 100644 > --- a/src/modules/evas/engines/gl_common/evas_gl_context.c > +++ b/src/modules/evas/engines/gl_common/evas_gl_context.c > @@ -1261,8 +1261,15 @@ _evas_gl_common_context_push(int rtype, > Eina_Bool clip, > int cx, int cy, int cw, int ch) > { > + GLuint current_tex = 0; > + GLuint current_texm = 0; > int pn = 0; > > + if (tex) > + current_tex = tex->ptt ? tex->ptt->texture : tex->pt->texture; > + if (texm) > + current_texm = texm->ptt ? texm->ptt->texture : tex->pt->texture; > + > #ifdef GLPIPES > again: > #endif > @@ -1277,8 +1284,8 @@ _evas_gl_common_context_push(int rtype, > for (i = pn; i >= 0; i--) > { > if ((gc->pipe[i].region.type == rtype) > - && (!tex || gc->pipe[i].shader.cur_tex == tex->pt->texture) > - && (!texm || gc->pipe[i].shader.cur_texm == > texm->pt->texture) > + && (!tex || gc->pipe[i].shader.cur_tex == current_tex) > + && (!texm || gc->pipe[i].shader.cur_texm == current_texm) > && (gc->pipe[i].shader.cur_prog == prog) > && (gc->pipe[i].shader.smooth == smooth) > && (gc->pipe[i].shader.blend == blend) > @@ -1318,8 +1325,8 @@ _evas_gl_common_context_push(int rtype, > } > #else > if (!((gc->pipe[pn].region.type == rtype) > - && (!tex || gc->pipe[pn].shader.cur_tex == tex->pt->texture) > - && (!texm || gc->pipe[pn].shader.cur_texm == texm->pt->texture) > + && (!tex || gc->pipe[pn].shader.cur_tex == current_tex) > + && (!texm || gc->pipe[pn].shader.cur_texm == current_texm) > && (gc->pipe[pn].shader.cur_prog == prog) > && (gc->pipe[pn].shader.smooth == smooth) > && (gc->pipe[pn].shader.blend == blend) > @@ -1553,8 +1560,10 @@ > evas_gl_common_context_image_push(Evas_Engine_GL_Context *gc, > int r, int g, int b, int a, > Eina_Bool smooth, Eina_Bool tex_only) > { > + Evas_GL_Texture_Pool *pt; > int pnum, nv, nc, nu, ns, i; > GLfloat tx1, tx2, ty1, ty2; > + GLfloat offsetx, offsety; > Eina_Bool blend = EINA_FALSE; > GLuint prog = gc->shared->shader[SHADER_IMG].prog; > int pn = 0, sam = 0; > @@ -1693,6 +1702,25 @@ > evas_gl_common_context_image_push(Evas_Engine_GL_Context *gc, > } > } > > + if (tex->ptt) > + { > + pt = tex->ptt; > + offsetx = tex->tx; > + offsety = tex->ty; > + > + // Adjusting sx, sy, sw and sh to real size of tiny texture > + sx = sx * (EVAS_GL_TILE_SIZE - 2) / tex->w; > + sw = sw * (EVAS_GL_TILE_SIZE - 2) / tex->w; > + sy = sy * (EVAS_GL_TILE_SIZE - 1) / tex->h; > + sh = sh * (EVAS_GL_TILE_SIZE - 1) / tex->h; > + } > + else > + { > + pt = tex->pt; > + offsetx = tex->x; > + offsety = tex->y; > + } > + > pn = _evas_gl_common_context_push(RTYPE_IMAGE, > gc, tex, NULL, > prog, > @@ -1702,7 +1730,7 @@ > evas_gl_common_context_image_push(Evas_Engine_GL_Context *gc, > 0, 0, 0, 0, 0); > > gc->pipe[pn].region.type = RTYPE_IMAGE; > - gc->pipe[pn].shader.cur_tex = tex->pt->texture; > + gc->pipe[pn].shader.cur_tex = pt->texture; > gc->pipe[pn].shader.cur_prog = prog; > gc->pipe[pn].shader.smooth = smooth; > gc->pipe[pn].shader.blend = blend; > @@ -1731,17 +1759,17 @@ > evas_gl_common_context_image_push(Evas_Engine_GL_Context *gc, > > if ((tex->im) && (tex->im->native.data) && (!tex->im->native.yinvert)) > { > - tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w; > - ty1 = 1.0 - ((double)(tex->y) + sy) / (double)tex->pt->h; > - tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w; > - ty2 = 1.0 - ((double)(tex->y) + sy + sh) / (double)tex->pt->h; > + tx1 = ((double)(offsetx) + sx) / (double)pt->w; > + ty1 = 1.0 - ((double)(offsety) + sy) / (double)pt->h; > + tx2 = ((double)(offsetx) + sx + sw) / (double)pt->w; > + ty2 = 1.0 - ((double)(offsety) + sy + sh) / (double)pt->h; > } > else > { > - tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w; > - ty1 = ((double)(tex->y) + sy) / (double)tex->pt->h; > - tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w; > - ty2 = ((double)(tex->y) + sy + sh) / (double)tex->pt->h; > + tx1 = ((double)(offsetx) + sx) / (double)pt->w; > + ty1 = ((double)(offsety) + sy) / (double)pt->h; > + tx2 = ((double)(offsetx) + sx + sw) / (double)pt->w; > + ty2 = ((double)(offsety) + sy + sh) / (double)pt->h; > } > > PUSH_VERTEX(pn, x , y , 0); > diff --git a/src/modules/evas/engines/gl_common/evas_gl_core.c > b/src/modules/evas/engines/gl_common/evas_gl_core.c > index 5145e0d..8fadc27 100644 > --- a/src/modules/evas/engines/gl_common/evas_gl_core.c > +++ b/src/modules/evas/engines/gl_common/evas_gl_core.c > @@ -117,7 +117,6 @@ _internal_resource_make_current(void *eng_data, > EVGL_Context *ctx) > } > } > > - > // Set context from input or from resource > if (ctx) > context = ctx->context; > diff --git a/src/modules/evas/engines/gl_common/evas_gl_image.c > b/src/modules/evas/engines/gl_common/evas_gl_image.c > index f8cdd11..8e721f8 100644 > --- a/src/modules/evas/engines/gl_common/evas_gl_image.c > +++ b/src/modules/evas/engines/gl_common/evas_gl_image.c > @@ -13,7 +13,7 @@ evas_gl_common_image_all_unload(Evas_Engine_GL_Context *gc) > { > if (!im->tex->pt->dyn.img) > { > - evas_gl_common_texture_free(im->tex, EINA_TRUE); > + evas_gl_common_texture_free(im->tex, EINA_TRUE); > im->tex = NULL; > } > } > @@ -574,11 +574,12 @@ evas_gl_common_image_update(Evas_Engine_GL_Context *gc, > Evas_GL_Image *im) > { > case EVAS_COLORSPACE_ARGB8888: > if ((im->tex) && > - ((im->dirty) || (ie->animated.animated))) > + ((im->dirty) || (ie->animated.animated) || > (ie->flags.updated_data))) > { > evas_cache_image_load_data(&im->im->cache_entry); > evas_gl_common_texture_update(im->tex, im->im); > evas_cache_image_unload_data(&im->im->cache_entry); > + ie->flags.updated_data = 0; > } > if (!im->tex) > { > diff --git a/src/modules/evas/engines/gl_common/evas_gl_preload.c > b/src/modules/evas/engines/gl_common/evas_gl_preload.c > new file mode 100644 > index 0000000..ffdb909 > --- /dev/null > +++ b/src/modules/evas/engines/gl_common/evas_gl_preload.c > @@ -0,0 +1,441 @@ > +#include "evas_gl_private.h" > + > +static Eina_Thread async_loader_thread; > +static Eina_Condition async_loader_cond; > +static Eina_Lock async_loader_lock; > + > +static Evas_GL_Texture_Async_Preload *async_current = NULL; > +static Eina_List *async_loader_tex = NULL; > +static Eina_List *async_loader_todie = NULL; > +static Eina_Bool async_loader_exit = EINA_FALSE; > +static Eina_Bool async_loader_running = EINA_FALSE; > +static Eina_Bool async_loader_standby = EINA_FALSE; > +static Eina_Bool async_current_cancel = EINA_FALSE; > +static int async_loader_init = 0; > + > +static void *async_engine_data = NULL; > +static evas_gl_make_current_cb async_gl_make_current = NULL; > + > +Eina_Bool > +evas_gl_preload_push(Evas_GL_Texture_Async_Preload *async) > +{ > + if (!async_loader_init) return EINA_FALSE; > + > + eina_lock_take(&async_loader_lock); > + async_loader_tex = eina_list_append(async_loader_tex, async); > + eina_lock_release(&async_loader_lock); > + > + return EINA_TRUE; > +} > + > +void > +evas_gl_preload_pop(Evas_GL_Texture *tex) > +{ > + Evas_GL_Texture_Async_Preload *async; > + Eina_List *l; > + > + if (!async_loader_init) return ; > + > + eina_lock_take(&async_loader_lock); > + > + if (async_gl_make_current && async_current && async_current->tex == tex) > + { > + Eina_Bool running = async_loader_running; > + evas_gl_make_current_cb tmp_cb = async_gl_make_current; > + void *tmp_data = async_engine_data; > + > + async_current_cancel = EINA_TRUE; > + eina_lock_release(&async_loader_lock); > + > + if (running) evas_gl_preload_render_lock(tmp_cb, tmp_data); > + > + evas_gl_common_texture_free(async_current->tex, EINA_FALSE); > + evas_cache_image_drop(&async_current->im->cache_entry); > + free(async_current); > + > + async_current = NULL; > + > + if (running) evas_gl_preload_render_unlock(tmp_cb, tmp_data); > + > + return ; > + } > + > + EINA_LIST_FOREACH(async_loader_tex, l, async) > + if (async->tex == tex) > + { > + async_loader_tex = eina_list_remove_list(async_loader_tex, l); > + > + evas_gl_common_texture_free(async->tex, EINA_FALSE); > + evas_cache_image_drop(&async->im->cache_entry); > + free(async); > + > + break; > + } > + > + eina_lock_release(&async_loader_lock); > +} > + > +static void > +_evas_gl_preload_main_loop_wakeup(void) > +{ > + Evas_GL_Texture_Async_Preload *async; > + evas_gl_make_current_cb cb = async_gl_make_current; > + void *data = async_engine_data; > + Eina_Bool running = async_loader_running; > + > + if (running) evas_gl_preload_render_lock(cb, data); > + EINA_LIST_FREE(async_loader_todie, async) > + { > + Eo *target; > + > + EINA_LIST_FREE(async->tex->targets, target) > + eo_do(target, evas_obj_image_pixels_dirty_set(EINA_TRUE)); > + async->im->cache_entry.flags.preload_done = 0; > + async->tex->was_preloaded = EINA_TRUE; > + > + async->tex->ptt->allocations = > eina_list_remove(async->tex->ptt->allocations, async->tex->aptt); > + pt_unref(async->tex->ptt); > + async->tex->ptt = NULL; > + free(async->tex->aptt); > + async->tex->aptt = NULL; > + > + evas_gl_common_texture_free(async->tex, EINA_FALSE); > + evas_cache_image_drop(&async->im->cache_entry); > + free(async); > + } > + if (running) evas_gl_preload_render_unlock(cb, data); > +} > + > +static void > +_evas_gl_preload_main_loop_wakeup_cb(void *target EINA_UNUSED, > + Evas_Callback_Type type EINA_UNUSED, > + void *event_info EINA_UNUSED) > +{ > + _evas_gl_preload_main_loop_wakeup(); > +} > + > +static Eina_Bool > +_evas_gl_preload_lock(void) > +{ > + eina_lock_take(&async_loader_lock); > + if (async_loader_standby) > + { > + async_gl_make_current(async_engine_data, NULL); > + > + async_loader_running = EINA_FALSE; > + > + eina_condition_signal(&async_loader_cond); > + > + eina_condition_wait(&async_loader_cond); > + if (async_loader_exit) return EINA_FALSE; > + > + async_gl_make_current(async_engine_data, async_engine_data); > + } > + async_loader_running = EINA_TRUE; > + eina_lock_release(&async_loader_lock); > + > + return EINA_TRUE; > +} > + > +static void * > +_evas_gl_preload_tile_async(void *data EINA_UNUSED, Eina_Thread t > EINA_UNUSED) > +{ > + eina_lock_take(&async_loader_lock); > + while (!async_loader_exit) > + { > + Evas_GL_Texture_Async_Preload *async; > + GLuint fmt; > + > + if (!async_loader_standby && async_loader_tex) > + goto get_next; > + > + retry: > + eina_condition_wait(&async_loader_cond); > + if (async_loader_exit) break ; > + > + get_next: > + // Get a texture to upload > + async = eina_list_data_get(async_loader_tex); > + async_loader_tex = eina_list_remove_list(async_loader_tex, > async_loader_tex); > + if (!async) continue; > + > + async_loader_running = EINA_TRUE; > + async_current = async; > + > + eina_lock_release(&async_loader_lock); > + > + // Switch context to this thread > + if (!async_gl_make_current(async_engine_data, async_engine_data)) > + { > + eina_lock_take(&async_loader_lock); > + async_loader_tex = eina_list_append(async_loader_tex, > async_current); > + async_loader_running = EINA_FALSE; > + async_current = NULL; > + > + if (async_loader_standby) > + eina_condition_signal(&async_loader_cond); > + > + goto retry; > + } > + > + // FIXME: loop until all subtile are uploaded or the image is about > to be deleted > + > + // TEMPORARY CODE JUST TO SEE IF IT WORK > + fmt = async->tex->pt->format; > + glBindTexture(GL_TEXTURE_2D, async->tex->pt->texture); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + if (async->unpack_row_length) > + { > + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + } > + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + > + // +-+ > + // +-+ > + // > + _tex_sub_2d(async->tex->x, async->tex->y, > + async->im->cache_entry.w, async->im->cache_entry.h, > + fmt, async->tex->pt->dataformat, > + async->im->image.data); > + // xxx > + // xxx > + // --- > + _tex_sub_2d(async->tex->x, async->tex->y + async->im->cache_entry.h, > + async->im->cache_entry.w, 1, > + fmt, async->tex->pt->dataformat, > + async->im->image.data + ((async->im->cache_entry.h - 1) > * async->im->cache_entry.w)); > + // xxx > + // xxx > + // o > + _tex_sub_2d(async->tex->x - 1, async->tex->y + > async->im->cache_entry.h, > + 1, 1, > + fmt, async->tex->pt->dataformat, > + async->im->image.data + ((async->im->cache_entry.h - 1) > * async->im->cache_entry.w)); > + // xxx > + // xxx > + // o > + _tex_sub_2d(async->tex->x + async->im->cache_entry.w, async->tex->y > + async->im->cache_entry.h, > + 1, 1, > + fmt, async->tex->pt->dataformat, > + async->im->image.data + ((async->im->cache_entry.h - 1) > * async->im->cache_entry.w) + (async->im->cache_entry.w - 1)); > + if (async->unpack_row_length) > + { > + glPixelStorei(GL_UNPACK_ROW_LENGTH, async->im->cache_entry.w); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + // |xxx > + // |xxx > + // > + _tex_sub_2d(async->tex->x - 1, async->tex->y, > + 1, async->im->cache_entry.h, > + fmt, async->tex->pt->dataformat, > + async->im->image.data); > + // xxx| > + // xxx| > + // > + _tex_sub_2d(async->tex->x + async->im->cache_entry.w, > async->tex->y, > + 1, async->im->cache_entry.h, > + fmt, async->tex->pt->dataformat, > + async->im->image.data + (async->im->cache_entry.w - > 1)); > + } > + else > + { > + DATA32 *tpix, *ps, *pd; > + int i; > + > + tpix = alloca(async->im->cache_entry.h * sizeof(DATA32)); > + pd = tpix; > + ps = async->im->image.data; > + for (i = 0; i < (int)async->im->cache_entry.h; i++) > + { > + *pd = *ps; > + pd++; > + ps += async->im->cache_entry.w; > + } > + // |xxx > + // |xxx > + // > + _tex_sub_2d(async->tex->x - 1, async->tex->y, > + 1, async->im->cache_entry.h, > + fmt, async->tex->pt->dataformat, > + tpix); > + pd = tpix; > + ps = async->im->image.data + (async->im->cache_entry.w - 1); > + for (i = 0; i < (int)async->im->cache_entry.h; i++) > + { > + *pd = *ps; > + pd++; > + ps += async->im->cache_entry.w; > + } > + // xxx| > + // xxx| > + // > + _tex_sub_2d(async->tex->x + async->im->cache_entry.w, > async->tex->y, > + 1, async->im->cache_entry.h, > + fmt, async->tex->pt->dataformat, > + tpix); > + } > + > + // Switch back to current texture > + if (async->tex->ptt->texture != > async->tex->gc->pipe[0].shader.cur_tex) > + { > + glBindTexture(GL_TEXTURE_2D, > async->tex->gc->pipe[0].shader.cur_tex); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + } > + > + // Shall we block now ? > + if (!_evas_gl_preload_lock()) > + break; > + > + // Release context > + async_gl_make_current(async_engine_data, NULL); > + > + evas_async_events_put(NULL, 0, NULL, > _evas_gl_preload_main_loop_wakeup_cb); > + > + eina_lock_take(&async_loader_lock); > + async_current = NULL; > + async_loader_todie = eina_list_append(async_loader_todie, async); > + async_loader_running = EINA_FALSE; > + > + if (async_loader_standby) > + eina_condition_signal(&async_loader_cond); > + } > + eina_lock_release(&async_loader_lock); > + > + return NULL; > +} > + > +// In the main loop > +// Push stuff on the todo queue > +// Upload the mini texture > +// Use the mini texture > +// Once download of the big texture, destroy mini texture and image data > + > + > +// Put the async preloader on standby > +void > +evas_gl_preload_render_lock(evas_gl_make_current_cb make_current, void > *engine_data) > +{ > + if (!async_loader_init) return ; > + eina_lock_take(&async_loader_lock); > + if (async_loader_running) > + { > + async_loader_standby = EINA_TRUE; > + eina_condition_wait(&async_loader_cond); > + > + make_current(engine_data, engine_data); > + > + async_engine_data = NULL; > + async_gl_make_current = NULL; > + } > + > + eina_lock_release(&async_loader_lock); > +} > + > +// Let the async preloader run ! > +void > +evas_gl_preload_render_unlock(evas_gl_make_current_cb make_current, void > *engine_data) > +{ > + if (!async_loader_init) return ; > + if (!make_current) return ; > + > + eina_lock_take(&async_loader_lock); > + if (!async_loader_running && (async_loader_tex || async_current)) > + { > + make_current(engine_data, NULL); > + > + async_gl_make_current = make_current; > + async_engine_data = engine_data; > + > + async_loader_standby = EINA_FALSE; > + eina_condition_signal(&async_loader_cond); > + } > + eina_lock_release(&async_loader_lock); > +} > + > +// add a way to destroy surface and temporarily stop the rendering of the > image > +void > +evas_gl_preload_render_relax(evas_gl_make_current_cb make_current, void > *engine_data) > +{ > + if (engine_data != async_engine_data) return ; > + > + evas_gl_preload_render_lock(make_current, engine_data); > +} > + > +static Eina_Bool > +_evas_gl_preload_target_die(void *data, Eo *obj, > + const Eo_Event_Description *desc EINA_UNUSED, > void *event_info EINA_UNUSED) > +{ > + Evas_GL_Texture *tex = data; > + > + evas_gl_preload_target_unregister(tex, obj); > + > + return EO_CALLBACK_CONTINUE; > +} > + > +void > +evas_gl_preload_target_register(Evas_GL_Texture *tex, Eo *target) > +{ > + eo_do(target, > + eo_event_callback_add(EO_EV_DEL, _evas_gl_preload_target_die, tex)); > + tex->targets = eina_list_append(tex->targets, target); > + tex->references++; > +} > + > +void > +evas_gl_preload_target_unregister(Evas_GL_Texture *tex, Eo *target) > +{ > + Eina_List *l; > + const Eo *o; > + > + eo_do(target, > + eo_event_callback_del(EO_EV_DEL, _evas_gl_preload_target_die, tex)); > + > + EINA_LIST_FOREACH(tex->targets, l, o) > + if (o == target) > + { > + void *data = async_engine_data; > + evas_gl_make_current_cb cb = async_gl_make_current; > + Eina_Bool running = async_loader_running; > + > + if (running) evas_gl_preload_render_lock(cb, data); > + tex->targets = eina_list_remove_list(tex->targets, l); > + evas_gl_common_texture_free(tex, EINA_FALSE); > + if (running) evas_gl_preload_render_unlock(cb, data); > + > + break; > + } > +} > + > +int > +evas_gl_preload_init(void) > +{ > + if (async_loader_init++) return async_loader_init; > + > + eina_lock_new(&async_loader_lock); > + eina_condition_new(&async_loader_cond, &async_loader_lock); > + > + if (!eina_thread_create(&async_loader_thread, EINA_THREAD_BACKGROUND, 0, > _evas_gl_preload_tile_async, NULL)) > + { > + // FIXME: handle error case > + } > + > + return async_loader_init; > +} > + > +int > +evas_gl_preload_shutdown(void) > +{ > + if (--async_loader_init) return async_loader_init; > + > + async_loader_exit = EINA_TRUE; > + eina_condition_signal(&async_loader_cond); > + > + eina_thread_join(async_loader_thread); > + > + eina_condition_free(&async_loader_cond); > + eina_lock_free(&async_loader_lock); > + > + return async_loader_init; > +} > diff --git a/src/modules/evas/engines/gl_common/evas_gl_texture.c > b/src/modules/evas/engines/gl_common/evas_gl_texture.c > index 0c07ffa..426549c 100644 > --- a/src/modules/evas/engines/gl_common/evas_gl_texture.c > +++ b/src/modules/evas/engines/gl_common/evas_gl_texture.c > @@ -194,13 +194,6 @@ evas_gl_common_texture_light_free(Evas_GL_Texture *tex) > free(tex); > } > > -static void > -_tex_sub_2d(int x, int y, int w, int h, int fmt, int type, const void *pix) > -{ > - glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, fmt, type, pix); > - GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > -} > - > static Evas_GL_Texture_Pool * > _pool_tex_new(Evas_Engine_GL_Context *gc, int w, int h, int intformat, > GLenum format) > { > @@ -711,7 +704,7 @@ evas_gl_texture_pool_empty(Evas_GL_Texture_Pool *pt) > pt->h = 0; > } > > -static void > +void > pt_unref(Evas_GL_Texture_Pool *pt) > { > if (!pt) return; > @@ -814,7 +807,7 @@ evas_gl_common_texture_update(Evas_GL_Texture *tex, > RGBA_Image *im) > { > GLuint fmt; > > - if (!im->image.data) return; > + if (!im->cache_entry.flags.loaded) return; > > if (tex->alpha != im->cache_entry.flags.alpha) > { > @@ -830,8 +823,101 @@ evas_gl_common_texture_update(Evas_GL_Texture *tex, > RGBA_Image *im) > *matching_format[lformat].intformat, > *matching_format[lformat].format); > } > + // If image was preloaded then we need a ptt > if (!tex->pt) return; > > + // if preloaded, then async push it in after uploading a miniature of it > + if (im->cache_entry.flags.preload_done && tex->w > 2 * EVAS_GL_TILE_SIZE > && tex->h > 2 * EVAS_GL_TILE_SIZE) > + { > + Evas_GL_Texture_Async_Preload *async; > + int *in; > + int out[EVAS_GL_TILE_SIZE * EVAS_GL_TILE_SIZE]; > + float xstep, ystep; > + float x, y; > + int i, j; > + int lformat; > + int u, v; > + > + if (tex->ptt) return ; > + > + xstep = (float)tex->w / (EVAS_GL_TILE_SIZE - 2); > + ystep = (float)tex->h / (EVAS_GL_TILE_SIZE - 1); > + in = (int*) im->image.data; > + > + for (y = 0, j = 0; j < EVAS_GL_TILE_SIZE - 1; y += ystep, j++) > + { > + out[j * EVAS_GL_TILE_SIZE] = in[(int)y * im->cache_entry.w]; > + for (x = 0, i = 1; i < EVAS_GL_TILE_SIZE - 1; x += xstep, i++) > + out[j * EVAS_GL_TILE_SIZE + i] = in[(int)y * > im->cache_entry.w + (int)x]; > + out[j * EVAS_GL_TILE_SIZE + i] = in[(int)y * im->cache_entry.w > + (int)(x - xstep)]; > + } > + > + memcpy(&out[j * EVAS_GL_TILE_SIZE], &out[(j - 1) * > EVAS_GL_TILE_SIZE], EVAS_GL_TILE_SIZE * sizeof (int)); > + > + // out is a miniature of the texture, upload that now and schedule > the data for later. > + > + // Creating the mini picture texture > + lformat = _evas_gl_texture_search_format(tex->alpha, > tex->gc->shared->info.bgra); > + tex->ptt = _pool_tex_find(tex->gc, EVAS_GL_TILE_SIZE, > EVAS_GL_TILE_SIZE, > + *matching_format[lformat].intformat, > + *matching_format[lformat].format, > + &u, &v, &tex->aptt, > + > tex->gc->shared->info.tune.atlas.max_alloc_size); > + if (!tex->ptt) > + goto upload; > + tex->aptt->tex = tex; > + > + tex->tx = u + 1; > + tex->ty = v; > + tex->ptt->references++; > + > + // Bind and upload ! Vooom ! > + fmt = tex->ptt->format; > + glBindTexture(GL_TEXTURE_2D, tex->ptt->texture); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + if (tex->gc->shared->info.unpack_row_length) > + { > + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + } > + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + > + _tex_sub_2d(u, tex->ty, EVAS_GL_TILE_SIZE, EVAS_GL_TILE_SIZE, fmt, > tex->ptt->dataformat, out); > + > + // Switch back to current texture > + if (tex->ptt->texture != tex->gc->pipe[0].shader.cur_tex) > + { > + glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + } > + > + // Now prepare uploading the main texture before returning; > + async = malloc(sizeof (Evas_GL_Texture_Async_Preload)); > + if (!async) > + { > + goto upload; > + } > + > + async->tex = tex; > + async->tex->references++; > + async->im = im; > + evas_cache_image_ref(&async->im->cache_entry); > + async->unpack_row_length = tex->gc->shared->info.unpack_row_length; > + > + if (evas_gl_preload_push(async)) > + return ; > + > + // Failed to start asynchronous upload, likely due to preload not > being supported by the backend > + async->tex->references--; > + evas_cache_image_drop(&async->im->cache_entry); > + free(async); > + > + upload: > + pt_unref(tex->ptt); > + tex->ptt = NULL; > + } > + > fmt = tex->pt->format; > glBindTexture(GL_TEXTURE_2D, tex->pt->texture); > GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > @@ -939,6 +1025,13 @@ void > evas_gl_common_texture_free(Evas_GL_Texture *tex, Eina_Bool force > EINA_UNUSED) > { > if (!tex) return; > + if (force) > + { > + evas_gl_preload_pop(tex); > + > + while (tex->targets) > + evas_gl_preload_target_unregister(tex, > eina_list_data_get(tex->targets)); > + } > tex->references--; > if (tex->references != 0) return; > if (tex->fglyph) > diff --git a/src/modules/evas/engines/gl_x11/evas_engine.c > b/src/modules/evas/engines/gl_x11/evas_engine.c > index 7f408fd..9441d6d 100644 > --- a/src/modules/evas/engines/gl_x11/evas_engine.c > +++ b/src/modules/evas/engines/gl_x11/evas_engine.c > @@ -73,6 +73,8 @@ typedef int (*glsym_func_int) (); > typedef unsigned int (*glsym_func_uint) (); > typedef const char *(*glsym_func_const_char_ptr) (); > > +static Eina_Bool eng_preload_make_current(void *data, void *doit); > + > #ifdef GL_GLES > > #ifndef EGL_NATIVE_PIXMAP_KHR > @@ -702,10 +704,6 @@ gl_extn_veto(Render_Engine *re) > { > extn_have_buffer_age = 0; > } > - if (!strstr(str, "swap_buffers_with_damage")) > - { > - glsym_eglSwapBuffersWithDamage = NULL; > - } > } > else > { > @@ -808,6 +806,7 @@ static void > _re_winfree(Render_Engine *re) > { > if (!re->win->surf) return; > + evas_gl_preload_render_relax(eng_preload_make_current, re); > eng_window_unsurf(re->win); > } > > @@ -877,6 +876,7 @@ eng_setup(Evas *eo_e, void *in) > evas_common_font_init(); > evas_common_draw_init(); > evas_common_tilebuf_init(); > + evas_gl_preload_init(); > gl_extn_veto(re); > // evgl_engine_init(re, &evgl_funcs); > initted = 1; > @@ -1033,6 +1033,8 @@ eng_output_free(void *data) > > if (re) > { > + evas_gl_preload_render_relax(eng_preload_make_current, re); > + > #if 0 > #ifdef GL_GLES > // Destroy the resource surface > @@ -1070,6 +1072,7 @@ eng_output_free(void *data) > } > if ((initted == 1) && (gl_wins == 0)) > { > + evas_gl_preload_shutdown(); > evas_common_image_shutdown(); > evas_common_font_shutdown(); > initted = 0; > @@ -1213,6 +1216,42 @@ _merge_rects(Tilebuf *tb, Tilebuf_Rect *r1, > Tilebuf_Rect *r2, Tilebuf_Rect *r3) > /* vsync games - not for now though */ > #define VSYNC_TO_SCREEN 1 > > +static Eina_Bool > +eng_preload_make_current(void *data, void *doit) > +{ > + Render_Engine *re = data; > + > + if (doit) > + { > +#ifdef GL_GLES > + if (!eglMakeCurrent(re->win->egl_disp, re->win->egl_surface[0], > re->win->egl_surface[0], re->win->egl_context[0])) > + return EINA_FALSE; > +#else > + if (!glXMakeCurrent(re->info->info.display, re->win->win, > re->win->context)) > + { > + ERR("glXMakeCurrent(%p, 0x%x, %p) failed", > re->info->info.display, (unsigned int)re->win->win, (void *)re->win->context); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + return EINA_FALSE; > + } > +#endif > + } > + else > + { > +#ifdef GL_GLES > + if (!eglMakeCurrent(re->win->egl_disp, EGL_NO_SURFACE, > EGL_NO_SURFACE, EGL_NO_CONTEXT)) > + return EINA_FALSE; > +#else > + if (!glXMakeCurrent(re->info->info.display, None, NULL)) > + { > + ERR("glXMakeCurrent(%p, None, NULL) failed", > re->info->info.display); > + GLERR(__FUNCTION__, __FILE__, __LINE__, ""); > + return EINA_FALSE; > + } > +#endif > + } > + return EINA_TRUE; > +} > + > static void * > eng_output_redraws_next_update_get(void *data, int *x, int *y, int *w, int > *h, int *cx, int *cy, int *cw, int *ch) > { > @@ -1353,6 +1392,7 @@ eng_output_redraws_next_update_get(void *data, int *x, > int *y, int *w, int *h, i > } > if (first_rect) > { > + evas_gl_preload_render_lock(eng_preload_make_current, re); > #ifdef GL_GLES > // dont need to for egl - eng_window_use() can check for other > ctxt's > #else > @@ -1433,11 +1473,11 @@ eng_output_flush(void *data, Evas_Render_Mode > render_mode) > { > Render_Engine *re; > > - if (render_mode == EVAS_RENDER_MODE_ASYNC_INIT) return; > + if (render_mode == EVAS_RENDER_MODE_ASYNC_INIT) goto end; > > re = (Render_Engine *)data; > - if (!_re_wincheck(re)) return; > - if (!re->win->draw.drew) return; > + if (!_re_wincheck(re)) goto end; > + if (!re->win->draw.drew) goto end; > > re->win->draw.drew = 0; > eng_window_use(re->win); > @@ -1454,7 +1494,7 @@ eng_output_flush(void *data, Evas_Render_Mode > render_mode) > { > re->info->callback.pre_swap(re->info->callback.data, re->evas); > } > - if ((glsym_eglSwapBuffersWithDamage) && (re->mode != MODE_FULL)) > + if ((glsym_eglSwapBuffersRegion) && (re->mode != MODE_FULL)) > { > EGLint num = 0, *rects = NULL, i = 0; > Tilebuf_Rect *r; > @@ -1505,9 +1545,9 @@ eng_output_flush(void *data, Evas_Render_Mode > render_mode) > } > i += 4; > } > - glsym_eglSwapBuffersWithDamage(re->win->egl_disp, > - re->win->egl_surface[0], > - rects, num); > + glsym_eglSwapBuffersRegion(re->win->egl_disp, > + re->win->egl_surface[0], > + num, rects); > } > } > else > @@ -1574,6 +1614,9 @@ eng_output_flush(void *data, Evas_Render_Mode > render_mode) > evas_common_tilebuf_free_render_rects(re->rects); > re->rects = NULL; > } > + > + end: > + evas_gl_preload_render_unlock(eng_preload_make_current, re); > } > > static void > @@ -2771,9 +2814,10 @@ eng_image_data_put(void *data, void *image, DATA32 > *image_data) > } > > static void > -eng_image_data_preload_request(void *data EINA_UNUSED, void *image, const Eo > *target) > +eng_image_data_preload_request(void *data, void *image, const Eo *target) > { > Evas_GL_Image *gim = image; > + Render_Engine *re = data; > RGBA_Image *im; > > if (!gim) return; > @@ -2781,6 +2825,9 @@ eng_image_data_preload_request(void *data EINA_UNUSED, > void *image, const Eo *ta > im = (RGBA_Image *)gim->im; > if (!im) return; > evas_cache_image_preload_data(&im->cache_entry, target, NULL, NULL, > NULL); > + if (!gim->tex) > + gim->tex = evas_gl_common_texture_new(re->win->gl_context, gim->im); > + evas_gl_preload_target_register(gim->tex, (Eo*) target); > } > > static void > @@ -2794,6 +2841,7 @@ eng_image_data_preload_cancel(void *data EINA_UNUSED, > void *image, const Eo *tar > im = (RGBA_Image *)gim->im; > if (!im) return; > evas_cache_image_preload_cancel(&im->cache_entry, target); > + evas_gl_preload_target_unregister(gim->tex, (Eo*) target); > } > > static Eina_Bool > diff --git a/src/modules/evas/engines/gl_x11/evas_x_main.c > b/src/modules/evas/engines/gl_x11/evas_x_main.c > index d0de1df..91015dc 100644 > --- a/src/modules/evas/engines/gl_x11/evas_x_main.c > +++ b/src/modules/evas/engines/gl_x11/evas_x_main.c > @@ -454,11 +454,57 @@ eng_window_free(Evas_GL_X11_Window *gw) > free(gw); > } > > +static Eina_Bool > +eng_window_make_current(void *data, void *doit) > +{ > + Evas_GL_X11_Window *gw = data; > + > +#ifdef GL_GLES > + if (doit) > + { > + if (!eglMakeCurrent(gw->egl_disp, gw->egl_surface[0], > gw->egl_surface[0], gw->egl_context[0])) > + return EINA_FALSE; > + } > + else > + { > + if (!eglMakeCurrent(gw->egl_disp, EGL_NO_SURFACE, EGL_NO_SURFACE, > EGL_NO_CONTEXT)) > + return EINA_FALSE; > + } > +#else > + if (doit) > + { > + if (gw->glxwin) > + { > + if (!glXMakeContextCurrent(gw->disp, gw->glxwin, gw->glxwin, > gw->context)) > + { > + ERR("glXMakeContextCurrent(%p, %p, %p, %p)", (void > *)gw->disp, (void *)gw->glxwin, (void *)gw->glxwin, (void *)gw->context); > + return EINA_FALSE; > + } > + } > + else > + { > + if (!glXMakeCurrent(gw->disp, gw->win, gw->context)) > + { > + ERR("glXMakeCurrent(%p, 0x%x, %p) failed", gw->disp, > (unsigned int)gw->win, (void *)gw->context); > + return EINA_FALSE; > + } > + } > + } > + else > + { > + if (!glXMakeCurrent(gw->disp, None, NULL)) > + return EINA_FALSE; > + } > +#endif > + return EINA_TRUE; > +} > + > void > eng_window_use(Evas_GL_X11_Window *gw) > { > Eina_Bool force_use = EINA_FALSE; > > + evas_gl_preload_render_lock(eng_window_make_current, gw); > #ifdef GL_GLES > if (_evas_gl_x11_window) > { > ------------------------------------------------------------------------------ This SF.net email is sponsored by Windows: Build for Windows Store. http://p.sf.net/sfu/windows-dev2dev _______________________________________________ enlightenment-devel mailing list enlightenment-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/enlightenment-devel