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

evas - clean up whitespace and 80 column wrapping and commented out code 

this doenst change functionality but just cleans up the file
whitespacing and formatting and removed commented out junk, 80 column
wrapping/overflow etc.
This commit is contained in:
Carsten Haitzler 2016-12-28 12:56:08 +09:00
parent 8424c2b4a3
commit ef49935f72
2 changed files with 306 additions and 510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
src/lib/evas/cache/evas_cache_engine_image.c vendored
View File

@ -49,19 +49,19 @@ _evas_cache_engine_image_remove_activ(Evas_Cache_Engine_Image *cache,
if (eim->flags.cached) if (eim->flags.cached)
{ {
if (eim->flags.dirty) if (eim->flags.dirty)
{ cache->dirty = eina_inlist_remove(cache->dirty,
cache->dirty = eina_inlist_remove(cache->dirty, EINA_INLIST_GET(eim)); EINA_INLIST_GET(eim));
}
else else
if (eim->flags.activ)
{ {
if (eim->flags.activ)
eina_hash_del(cache->activ, eim->cache_key, eim); eina_hash_del(cache->activ, eim->cache_key, eim);
}
else else
{ {
cache->usage -= cache->func.mem_size_get(eim); cache->usage -= cache->func.mem_size_get(eim);
eina_hash_del(cache->inactiv, eim->cache_key, eim); eina_hash_del(cache->inactiv, eim->cache_key, eim);
cache->lru = eina_inlist_remove(cache->lru, EINA_INLIST_GET(eim)); cache->lru = eina_inlist_remove(cache->lru,
EINA_INLIST_GET(eim));
}
} }
eim->flags.cached = 0; eim->flags.cached = 0;
eim->flags.dirty = 0; eim->flags.dirty = 0;
@ -78,10 +78,8 @@ _evas_cache_engine_image_alloc(Evas_Cache_Engine_Image *cache,
assert(cache); assert(cache);
if (cache->func.alloc) if (cache->func.alloc) eim = cache->func.alloc();
eim = cache->func.alloc(); else eim = malloc(sizeof (Engine_Image_Entry));
else
eim = malloc(sizeof (Engine_Image_Entry));
if (!eim) goto on_error; if (!eim) goto on_error;
memset(eim, 0, sizeof (Engine_Image_Entry)); memset(eim, 0, sizeof (Engine_Image_Entry));
@ -106,10 +104,8 @@ _evas_cache_engine_image_alloc(Evas_Cache_Engine_Image *cache,
eim->references = 0; eim->references = 0;
eim->cache_key = hkey; eim->cache_key = hkey;
if (hkey) if (hkey) _evas_cache_engine_image_make_active(cache, eim, hkey);
_evas_cache_engine_image_make_active(cache, eim, hkey); else _evas_cache_engine_image_make_dirty(cache, eim);
else
_evas_cache_engine_image_make_dirty(cache, eim);
return eim; return eim;
@ -120,7 +116,8 @@ _evas_cache_engine_image_alloc(Evas_Cache_Engine_Image *cache,
} }
static void static void
_evas_cache_engine_image_dealloc(Evas_Cache_Engine_Image *cache, Engine_Image_Entry *eim) _evas_cache_engine_image_dealloc(Evas_Cache_Engine_Image *cache,
Engine_Image_Entry *eim)
{ {
Image_Entry *im; Image_Entry *im;
@ -132,10 +129,7 @@ _evas_cache_engine_image_dealloc(Evas_Cache_Engine_Image *cache, Engine_Image_En
cache->func.destructor(eim); cache->func.destructor(eim);
if (im) evas_cache_image_drop(im); if (im) evas_cache_image_drop(im);
if (cache->func.dealloc) if (cache->func.dealloc) cache->func.dealloc(eim);
{
cache->func.dealloc(eim);
}
else else
{ {
memset(eim, 0, sizeof(Engine_Image_Entry)); memset(eim, 0, sizeof(Engine_Image_Entry));
@ -147,7 +141,6 @@ EAPI int
evas_cache_engine_image_usage_get(Evas_Cache_Engine_Image *cache) evas_cache_engine_image_usage_get(Evas_Cache_Engine_Image *cache)
{ {
assert(cache != NULL); assert(cache != NULL);
return cache->usage; return cache->usage;
} }
@ -155,7 +148,6 @@ EAPI int
evas_cache_engine_image_get(Evas_Cache_Engine_Image *cache) evas_cache_engine_image_get(Evas_Cache_Engine_Image *cache)
{ {
assert(cache != NULL); assert(cache != NULL);
return cache->limit; return cache->limit;
} }
@ -163,18 +155,17 @@ EAPI void
evas_cache_engine_image_set(Evas_Cache_Engine_Image *cache, int limit) evas_cache_engine_image_set(Evas_Cache_Engine_Image *cache, int limit)
{ {
assert(cache != NULL); assert(cache != NULL);
cache->limit = limit; cache->limit = limit;
} }
EAPI Evas_Cache_Engine_Image * EAPI Evas_Cache_Engine_Image *
evas_cache_engine_image_init(const Evas_Cache_Engine_Image_Func *cb, Evas_Cache_Image *parent) evas_cache_engine_image_init(const Evas_Cache_Engine_Image_Func *cb,
Evas_Cache_Image *parent)
{ {
Evas_Cache_Engine_Image *new; Evas_Cache_Engine_Image *new;
new = malloc(sizeof (Evas_Cache_Engine_Image)); new = malloc(sizeof (Evas_Cache_Engine_Image));
if (!new) if (!new) return NULL;
return NULL;
new->func = *cb; new->func = *cb;
@ -195,18 +186,17 @@ evas_cache_engine_image_init(const Evas_Cache_Engine_Image_Func *cb, Evas_Cache_
} }
EAPI Evas_Cache_Engine_Image * EAPI Evas_Cache_Engine_Image *
evas_cache_engine_image_dup(const Evas_Cache_Engine_Image_Func *cb, Evas_Cache_Engine_Image *brother) evas_cache_engine_image_dup(const Evas_Cache_Engine_Image_Func *cb,
Evas_Cache_Engine_Image *brother)
{ {
Evas_Cache_Engine_Image *new; Evas_Cache_Engine_Image *new;
new = calloc(1, sizeof(Evas_Cache_Engine_Image)); new = calloc(1, sizeof(Evas_Cache_Engine_Image));
if (!new) if (!new) return NULL;
return NULL;
new->func = brother->func; new->func = brother->func;
#define ORD(Func) if (cb->Func) new->func.Func = cb->Func; #define ORD(Func) if (cb->Func) new->func.Func = cb->Func;
ORD(key); ORD(key);
ORD(constructor); ORD(constructor);
ORD(destructor); ORD(destructor);
@ -217,7 +207,6 @@ evas_cache_engine_image_dup(const Evas_Cache_Engine_Image_Func *cb, Evas_Cache_E
ORD(load); ORD(load);
ORD(mem_size_get); ORD(mem_size_get);
ORD(debug); ORD(debug);
#undef ORD #undef ORD
new->limit = -1; new->limit = -1;
@ -237,12 +226,13 @@ evas_cache_engine_image_dup(const Evas_Cache_Engine_Image_Func *cb, Evas_Cache_E
} }
static Eina_Bool static Eina_Bool
_evas_cache_engine_image_free_cb(EINA_UNUSED const Eina_Hash *hash, EINA_UNUSED const void *key, void *data, void *fdata) _evas_cache_engine_image_free_cb(EINA_UNUSED const Eina_Hash *hash,
EINA_UNUSED const void *key,
void *data, void *fdata)
{ {
Eina_List **delete_list = fdata; Eina_List **delete_list = fdata;
*delete_list = eina_list_prepend(*delete_list, data); *delete_list = eina_list_prepend(*delete_list, data);
return EINA_TRUE; return EINA_TRUE;
} }
@ -270,36 +260,39 @@ evas_cache_engine_image_shutdown(Evas_Cache_Engine_Image *cache)
if (cache->func.debug) cache->func.debug("shutdown-engine", NULL); if (cache->func.debug) cache->func.debug("shutdown-engine", NULL);
eina_hash_foreach(cache->inactiv, _evas_cache_engine_image_free_cb, &delete_list); eina_hash_foreach(cache->inactiv, _evas_cache_engine_image_free_cb,
eina_hash_foreach(cache->activ, _evas_cache_engine_image_free_cb, &delete_list); &delete_list);
eina_hash_foreach(cache->activ, _evas_cache_engine_image_free_cb,
&delete_list);
while (delete_list) while (delete_list)
{ {
_evas_cache_engine_image_dealloc(cache, eina_list_data_get(delete_list)); _evas_cache_engine_image_dealloc(cache,
eina_list_data_get(delete_list));
delete_list = eina_list_remove_list(delete_list, delete_list); delete_list = eina_list_remove_list(delete_list, delete_list);
} }
eina_hash_free(cache->inactiv); eina_hash_free(cache->inactiv);
eina_hash_free(cache->activ); eina_hash_free(cache->activ);
/* This is mad, I am about to destroy image still alive, but we need to prevent leak. */ /* This is mad, I am about to destroy image still alive, but we need to
* prevent leak. */
while (cache->dirty) while (cache->dirty)
{ {
eim = (Engine_Image_Entry *)cache->dirty; eim = (Engine_Image_Entry *)cache->dirty;
_evas_cache_engine_image_dealloc(cache, eim); _evas_cache_engine_image_dealloc(cache, eim);
} }
evas_cache_image_shutdown(cache->parent); evas_cache_image_shutdown(cache->parent);
if (cache->brother) if (cache->brother) evas_cache_engine_image_shutdown(cache->brother);
evas_cache_engine_image_shutdown(cache->brother);
free(cache); free(cache);
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_request(Evas_Cache_Engine_Image *cache, evas_cache_engine_image_request(Evas_Cache_Engine_Image *cache,
const char *file, const char *key, const char *file, const char *key,
Evas_Image_Load_Opts *lo, void *data, int *error) Evas_Image_Load_Opts *lo, void *data,
int *error)
{ {
Engine_Image_Entry *eim; Engine_Image_Entry *eim;
Image_Entry *im; Image_Entry *im;
@ -313,13 +306,10 @@ evas_cache_engine_image_request(Evas_Cache_Engine_Image *cache,
eim = NULL; eim = NULL;
im = evas_cache_image_request(cache->parent, file, key, lo, error); im = evas_cache_image_request(cache->parent, file, key, lo, error);
if (!im) if (!im) goto on_error;
goto on_error;
if (cache->func.key) if (cache->func.key) ekey = cache->func.key(im, file, key, lo, data);
ekey = cache->func.key(im, file, key, lo, data); else ekey = eina_stringshare_add(im->cache_key);
else
ekey = eina_stringshare_add(im->cache_key);
if (!ekey) if (!ekey)
{ {
*error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
@ -351,8 +341,7 @@ evas_cache_engine_image_request(Evas_Cache_Engine_Image *cache,
*error = cache->func.constructor(eim, data); *error = cache->func.constructor(eim, data);
if (*error != EVAS_LOAD_ERROR_NONE) goto on_error; if (*error != EVAS_LOAD_ERROR_NONE) goto on_error;
if (cache->func.debug) if (cache->func.debug) cache->func.debug("constructor-engine", eim);
cache->func.debug("constructor-engine", eim);
on_ok: on_ok:
eim->references++; eim->references++;
@ -363,10 +352,7 @@ evas_cache_engine_image_request(Evas_Cache_Engine_Image *cache,
{ {
if (im) evas_cache_image_drop(im); if (im) evas_cache_image_drop(im);
} }
else else _evas_cache_engine_image_dealloc(cache, eim);
{
_evas_cache_engine_image_dealloc(cache, eim);
}
return NULL; return NULL;
} }
@ -398,7 +384,9 @@ evas_cache_engine_image_drop(Engine_Image_Entry *eim)
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_dirty(Engine_Image_Entry *eim, unsigned int x, unsigned int y, unsigned int w, unsigned int h) evas_cache_engine_image_dirty(Engine_Image_Entry *eim,
unsigned int x, unsigned int y,
unsigned int w, unsigned int h)
{ {
Engine_Image_Entry *eim_dirty = eim; Engine_Image_Entry *eim_dirty = eim;
Image_Entry *im_dirty = NULL; Image_Entry *im_dirty = NULL;
@ -419,30 +407,28 @@ evas_cache_engine_image_dirty(Engine_Image_Entry *eim, unsigned int x, unsigned
im = eim->src; im = eim->src;
im_dirty = evas_cache_image_dirty(im, x, y, w, h); im_dirty = evas_cache_image_dirty(im, x, y, w, h);
/* If im == im_dirty, this meens that we have only one reference to the eim. */ /* If im == im_dirty, this meens that we have only one
* reference to the eim. */
if (im != im_dirty) if (im != im_dirty)
{ {
if (eim->references == 1) if (eim->references == 1)
{ {
_evas_cache_engine_image_remove_activ(cache, eim); _evas_cache_engine_image_remove_activ(cache, eim);
_evas_cache_engine_image_make_dirty(cache, eim); _evas_cache_engine_image_make_dirty(cache, eim);
eim->src = im_dirty; eim->src = im_dirty;
} }
else else alloc_eim = 1;
alloc_eim = 1;
} }
} }
else else
if (eim->references > 1)
{ {
alloc_eim = 1; if (eim->references > 1) alloc_eim = 1;
}
else else
{ {
_evas_cache_engine_image_remove_activ(cache, eim_dirty); _evas_cache_engine_image_remove_activ(cache, eim_dirty);
_evas_cache_engine_image_make_dirty(cache, eim_dirty); _evas_cache_engine_image_make_dirty(cache, eim_dirty);
} }
}
if (alloc_eim == 1) if (alloc_eim == 1)
{ {
@ -474,10 +460,8 @@ evas_cache_engine_image_dirty(Engine_Image_Entry *eim, unsigned int x, unsigned
on_error: on_error:
evas_cache_engine_image_drop(eim); evas_cache_engine_image_drop(eim);
if (eim_dirty && eim_dirty != eim) if (eim_dirty && eim_dirty != eim) evas_cache_engine_image_drop(eim_dirty);
evas_cache_engine_image_drop(eim_dirty); else if (im_dirty) evas_cache_image_drop(im_dirty);
else
if (im_dirty) evas_cache_image_drop(im_dirty);
return NULL; return NULL;
} }
@ -488,7 +472,6 @@ evas_cache_engine_image_alone(Engine_Image_Entry *eim, void *data)
Evas_Cache_Engine_Image *cache; Evas_Cache_Engine_Image *cache;
Image_Entry *im; Image_Entry *im;
assert(eim); assert(eim);
assert(eim->cache); assert(eim->cache);
@ -513,7 +496,8 @@ evas_cache_engine_image_alone(Engine_Image_Entry *eim, void *data)
} }
static Engine_Image_Entry * static Engine_Image_Entry *
_evas_cache_engine_image_push_dirty(Evas_Cache_Engine_Image *cache, Image_Entry *im, void *engine_data) _evas_cache_engine_image_push_dirty(Evas_Cache_Engine_Image *cache,
Image_Entry *im, void *engine_data)
{ {
Engine_Image_Entry *eim; Engine_Image_Entry *eim;
int error; int error;
@ -523,44 +507,46 @@ _evas_cache_engine_image_push_dirty(Evas_Cache_Engine_Image *cache, Image_Entry
eim->references = 1; eim->references = 1;
error = cache->func.update_data(eim, engine_data); error = cache->func.update_data(eim, engine_data);
if (cache->func.debug) if (cache->func.debug) cache->func.debug("dirty-update_data-engine", eim);
cache->func.debug("dirty-update_data-engine", eim);
if (error != 0) goto on_error; if (error != 0) goto on_error;
return eim; return eim;
on_error: on_error:
if (eim) if (eim) evas_cache_engine_image_drop(eim);
evas_cache_engine_image_drop(eim);
return NULL; return NULL;
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_copied_data(Evas_Cache_Engine_Image *cache, unsigned int w, unsigned int h, DATA32 *image_data, int alpha, Evas_Colorspace cspace, void *engine_data) evas_cache_engine_image_copied_data(Evas_Cache_Engine_Image *cache,
unsigned int w, unsigned int h,
DATA32 *image_data, int alpha,
Evas_Colorspace cspace, void *engine_data)
{ {
Image_Entry *im; Image_Entry *im;
assert(cache); assert(cache);
im = evas_cache_image_copied_data(cache->parent, w, h, image_data,
im = evas_cache_image_copied_data(cache->parent, w, h, image_data, alpha, cspace); alpha, cspace);
return _evas_cache_engine_image_push_dirty(cache, im, engine_data); return _evas_cache_engine_image_push_dirty(cache, im, engine_data);
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_data(Evas_Cache_Engine_Image *cache, unsigned int w, unsigned int h, DATA32 *image_data, int alpha, Evas_Colorspace cspace, void *engine_data) evas_cache_engine_image_data(Evas_Cache_Engine_Image *cache,
unsigned int w, unsigned int h,
DATA32 *image_data, int alpha,
Evas_Colorspace cspace, void *engine_data)
{ {
Image_Entry *im; Image_Entry *im;
assert(cache); assert(cache);
im = evas_cache_image_data(cache->parent, w, h, image_data, alpha, cspace); im = evas_cache_image_data(cache->parent, w, h, image_data, alpha, cspace);
return _evas_cache_engine_image_push_dirty(cache, im, engine_data); return _evas_cache_engine_image_push_dirty(cache, im, engine_data);
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_size_set(Engine_Image_Entry *eim, unsigned int w, unsigned int h) evas_cache_engine_image_size_set(Engine_Image_Entry *eim,
unsigned int w, unsigned int h)
{ {
Evas_Cache_Engine_Image *cache; Evas_Cache_Engine_Image *cache;
Engine_Image_Entry *new; Engine_Image_Entry *new;
@ -579,9 +565,7 @@ evas_cache_engine_image_size_set(Engine_Image_Entry *eim, unsigned int w, unsign
{ {
assert(eim->src); assert(eim->src);
if (eim->src->w == w if ((eim->src->w == w) && (eim->src->h == h)) return eim;
&& eim->src->h == h)
return eim;
im = evas_cache_image_size_set(eim->src, w, h); im = evas_cache_image_size_set(eim->src, w, h);
/* FIXME: Good idea to call update_data ? */ /* FIXME: Good idea to call update_data ? */
@ -605,11 +589,8 @@ evas_cache_engine_image_size_set(Engine_Image_Entry *eim, unsigned int w, unsign
return new; return new;
on_error: on_error:
if (new) if (new) evas_cache_engine_image_drop(new);
evas_cache_engine_image_drop(new); else if (im) evas_cache_image_drop(im);
else
if (im)
evas_cache_image_drop(im);
evas_cache_engine_image_drop(eim); evas_cache_engine_image_drop(eim);
return NULL; return NULL;
@ -627,25 +608,22 @@ evas_cache_engine_image_load_data(Engine_Image_Entry *eim)
if (eim->flags.loaded) return; if (eim->flags.loaded) return;
if (eim->src) if (eim->src) evas_cache_image_load_data(eim->src);
evas_cache_image_load_data(eim->src);
cache = eim->cache; cache = eim->cache;
if (cache->func.debug) if (cache->func.debug) cache->func.debug("load-engine", eim);
cache->func.debug("load-engine", eim);
if (eim->flags.dirty) if (eim->flags.dirty) size = cache->func.mem_size_get(eim);
size = cache->func.mem_size_get(eim);
cache = eim->cache; cache = eim->cache;
cache->func.load(eim, eim->src); cache->func.load(eim, eim->src);
if (eim->flags.dirty) if (eim->flags.dirty) cache->usage += cache->func.mem_size_get(eim) - size;
cache->usage += cache->func.mem_size_get(eim) - size;
eim->flags.loaded = 1; eim->flags.loaded = 1;
} }
EAPI Engine_Image_Entry * EAPI Engine_Image_Entry *
evas_cache_engine_image_engine(Evas_Cache_Engine_Image *cache, void *engine_data) evas_cache_engine_image_engine(Evas_Cache_Engine_Image *cache,
void *engine_data)
{ {
Engine_Image_Entry *eim; Engine_Image_Entry *eim;
Image_Entry *ie; Image_Entry *ie;
@ -659,24 +637,22 @@ evas_cache_engine_image_engine(Evas_Cache_Engine_Image *cache, void *engine_data
eim->references = 1; eim->references = 1;
error = cache->func.update_data(eim, engine_data); error = cache->func.update_data(eim, engine_data);
if (cache->func.debug) if (cache->func.debug) cache->func.debug("update_data-engine", eim);
cache->func.debug("update_data-engine", eim);
if (error != 0) goto on_error; if (error != 0) goto on_error;
return eim; return eim;
on_error: on_error:
if (!eim) if (!eim) evas_cache_image_drop(ie);
evas_cache_image_drop(ie); else evas_cache_engine_image_drop(eim);
else
evas_cache_engine_image_drop(eim);
return NULL; return NULL;
} }
EAPI void EAPI void
evas_cache_engine_image_colorspace(Engine_Image_Entry *eim, Evas_Colorspace cspace, void *engine_data) evas_cache_engine_image_colorspace(Engine_Image_Entry *eim,
Evas_Colorspace cspace, void *engine_data)
{ {
Evas_Cache_Engine_Image *cache = eim->cache; Evas_Cache_Engine_Image *cache = eim->cache;

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

@ -40,31 +40,25 @@ static int evas_image_no_mmap = -1;
#define EVAS_ALPHA_LINE_BUFFER_MIN_LEN 256 #define EVAS_ALPHA_LINE_BUFFER_MIN_LEN 256
#define EVAS_ALPHA_LINE_BUFFER_MAX_LEN 2048 #define EVAS_ALPHA_LINE_BUFFER_MAX_LEN 2048
static Image_Entry *_evas_common_rgba_image_new(void); static Image_Entry *_evas_common_rgba_image_new(void);
static void _evas_common_rgba_image_delete(Image_Entry *ie); static void _evas_common_rgba_image_delete(Image_Entry *ie);
static int _evas_common_rgba_image_surface_alloc(Image_Entry *ie,
static int _evas_common_rgba_image_surface_alloc(Image_Entry *ie, unsigned int w, unsigned int h); unsigned int w,
unsigned int h);
static void _evas_common_rgba_image_surface_delete(Image_Entry *ie); static void _evas_common_rgba_image_surface_delete(Image_Entry *ie);
static DATA32 *_evas_common_rgba_image_surface_pixels(Image_Entry *ie); static DATA32 *_evas_common_rgba_image_surface_pixels(Image_Entry *ie);
static void _evas_common_rgba_image_unload(Image_Entry *im); static void _evas_common_rgba_image_unload(Image_Entry *im);
static void _evas_common_rgba_image_dirty_region(Image_Entry *im,
static void _evas_common_rgba_image_dirty_region(Image_Entry *im, unsigned int x, unsigned int y, unsigned int w, unsigned int h); unsigned int x,
unsigned int y,
unsigned int w,
unsigned int h);
static int _evas_common_rgba_image_ram_usage(Image_Entry *ie); static int _evas_common_rgba_image_ram_usage(Image_Entry *ie);
/* Only called when references > 0. Need to provide a fresh copie of im. */ /* Only called when references > 0. Need to provide a fresh copie of im. */
/* The destination surface does have a surface, but no allocated pixel data. */ /* The destination surface does have a surface, but no allocated pixel data. */
static int _evas_common_rgba_image_dirty(Image_Entry* dst, const Image_Entry* src); static int _evas_common_rgba_image_dirty(Image_Entry* dst,
const Image_Entry* src);
#if 0
static void
_evas_common_rgba_image_debug(const char* context, Image_Entry *eim)
{
DBG("%p = [%s] {%s,%s} %i [%i|%i]", eim, context, eim->file, eim->key, eim->references, eim->w, eim->h);
}
#endif
static const Evas_Cache_Image_Func _evas_common_image_func = static const Evas_Cache_Image_Func _evas_common_image_func =
{ {
@ -83,30 +77,23 @@ static const Evas_Cache_Image_Func _evas_common_image_func =
evas_common_rgba_image_colorspace_set, evas_common_rgba_image_colorspace_set,
evas_common_load_rgba_image_data_from_file, evas_common_load_rgba_image_data_from_file,
_evas_common_rgba_image_ram_usage, _evas_common_rgba_image_ram_usage,
/* _evas_common_rgba_image_debug */ NULL // _evas_common_rgba_image_debug
NULL
}; };
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
static const Evas_Cache2_Image_Func _evas_common_image_func2 = static const Evas_Cache2_Image_Func _evas_common_image_func2 =
{ {
// _evas_common_rgba_image_new,
// _evas_common_rgba_image_delete,
_evas_common_rgba_image_surface_alloc, _evas_common_rgba_image_surface_alloc,
_evas_common_rgba_image_surface_delete, _evas_common_rgba_image_surface_delete,
_evas_common_rgba_image_surface_pixels, _evas_common_rgba_image_surface_pixels,
// evas_common_load_rgba_image_module_from_file,
// _evas_common_rgba_image_unload,
NULL, // _evas_common_rgba_image_dirty_region, NULL, // _evas_common_rgba_image_dirty_region,
NULL, // _evas_common_rgba_image_dirty, NULL, // _evas_common_rgba_image_dirty,
evas_common_rgba_image_size_set, evas_common_rgba_image_size_set,
evas_common_rgba_image_from_copied_data, evas_common_rgba_image_from_copied_data,
evas_common_rgba_image_from_data, evas_common_rgba_image_from_data,
NULL, // evas_common_rgba_image_colorspace_set, NULL, // evas_common_rgba_image_colorspace_set,
// evas_common_load_rgba_image_data_from_file,
_evas_common_rgba_image_ram_usage, _evas_common_rgba_image_ram_usage,
/* _evas_common_rgba_image_debug */ NULL // _evas_common_rgba_image_debug
NULL
}; };
#endif #endif
@ -120,11 +107,11 @@ _evas_common_rgba_image_surface_size(unsigned int w, unsigned int h,
#endif #endif
#define HUGE_PAGE_SIZE (2 * 1024 * 1024) #define HUGE_PAGE_SIZE (2 * 1024 * 1024)
#if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32)) #if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32))
# define ALIGN_TO_PAGE(Siz) (((Siz / PAGE_SIZE) + (Siz % PAGE_SIZE ? 1 : 0)) * PAGE_SIZE) # define ALIGN_TO_PAGE(Siz) \
(((Siz / PAGE_SIZE) + (Siz % PAGE_SIZE ? 1 : 0)) * PAGE_SIZE)
#else #else
# define ALIGN_TO_PAGE(Siz) Siz # define ALIGN_TO_PAGE(Siz) Siz
#endif #endif
int siz, block_size = 8; int siz, block_size = 8;
Eina_Bool reset_borders = EINA_TRUE; Eina_Bool reset_borders = EINA_TRUE;
@ -133,7 +120,7 @@ _evas_common_rgba_image_surface_size(unsigned int w, unsigned int h,
const char *s = getenv("EVAS_IMAGE_NO_MMAP"); const char *s = getenv("EVAS_IMAGE_NO_MMAP");
evas_image_no_mmap = s && (atoi(s)); evas_image_no_mmap = s && (atoi(s));
if (evas_image_no_mmap) if (evas_image_no_mmap)
WRN("EVAS_IMAGE_NO_MMAP is set, use this only for debugging purposes!"); WRN("EVAS_IMAGE_NO_MMAP is set, use this only for debugging!");
} }
switch (cspace) switch (cspace)
@ -173,16 +160,15 @@ _evas_common_rgba_image_surface_size(unsigned int w, unsigned int h,
if (b) *b = 0; if (b) *b = 0;
} }
if ((siz < PAGE_SIZE) || evas_image_no_mmap) if ((siz < PAGE_SIZE) || evas_image_no_mmap) return siz;
return siz;
return ALIGN_TO_PAGE(siz); return ALIGN_TO_PAGE(siz);
#undef ALIGN_TO_PAGE #undef ALIGN_TO_PAGE
} }
EAPI Eina_Bool EAPI Eina_Bool
_evas_common_rgba_image_plane_get(const RGBA_Image *im, int plane, Eina_Slice *slice) _evas_common_rgba_image_plane_get(const RGBA_Image *im, int plane,
Eina_Slice *slice)
{ {
unsigned char **csdata = NULL; unsigned char **csdata = NULL;
Evas_Colorspace cs; Evas_Colorspace cs;
@ -200,14 +186,12 @@ _evas_common_rgba_image_plane_get(const RGBA_Image *im, int plane, Eina_Slice *s
case EVAS_COLORSPACE_YCBCR422601_PL: case EVAS_COLORSPACE_YCBCR422601_PL:
case EVAS_COLORSPACE_YCBCR420NV12601_PL: case EVAS_COLORSPACE_YCBCR420NV12601_PL:
case EVAS_COLORSPACE_YCBCR420TM12601_PL: case EVAS_COLORSPACE_YCBCR420TM12601_PL:
if (!im->cs.data) if (!im->cs.data) return EINA_FALSE;
return EINA_FALSE;
csdata = im->cs.data; csdata = im->cs.data;
break; break;
default: default:
if (!im->image.data) if (!im->image.data) return EINA_FALSE;
return EINA_FALSE;
break; break;
} }
@ -337,19 +321,17 @@ _evas_common_rgba_image_plane_get(const RGBA_Image *im, int plane, Eina_Slice *s
} }
EAPI int EAPI int
_evas_common_rgba_image_data_offset(int rx, int ry, int rw, int rh, int plane, const RGBA_Image *im) _evas_common_rgba_image_data_offset(int rx, int ry, int rw, int rh,
int plane, const RGBA_Image *im)
{ {
// note: no stride support // note: no stride support
EINA_SAFETY_ON_NULL_RETURN_VAL(im, -1); EINA_SAFETY_ON_NULL_RETURN_VAL(im, -1);
const Image_Entry *ie = &im->cache_entry; const Image_Entry *ie = &im->cache_entry;
if ((rx < 0) || (ry < 0) || (rw < 0) || (rh < 0)) if ((rx < 0) || (ry < 0) || (rw < 0) || (rh < 0)) return -1;
return -1;
if (((rx + rw) > (int) ie->w) || ((ry + rh) > (int) ie->h)) if (((rx + rw) > (int) ie->w) || ((ry + rh) > (int) ie->h)) return -1;
return -1;
switch (ie->space) switch (ie->space)
{ {
@ -360,40 +342,31 @@ _evas_common_rgba_image_data_offset(int rx, int ry, int rw, int rh, int plane, c
case EVAS_COLORSPACE_GRY8: case EVAS_COLORSPACE_GRY8:
return ry * ie->w + rx; return ry * ie->w + rx;
case EVAS_COLORSPACE_RGB565_A5P: case EVAS_COLORSPACE_RGB565_A5P:
if (plane == 0) if (plane == 0) return (ry * ie->w + rx) * 2;
return (ry * ie->w + rx) * 2; else if (plane == 1) return ry * ie->w + rx + (ie->w * ie->h) * 2;
else if (plane == 1)
return ry * ie->w + rx + (ie->w * ie->h) * 2;
else return -1; else return -1;
// YUV // YUV
case EVAS_COLORSPACE_YCBCR422P601_PL: case EVAS_COLORSPACE_YCBCR422P601_PL:
case EVAS_COLORSPACE_YCBCR422P709_PL: case EVAS_COLORSPACE_YCBCR422P709_PL:
case EVAS_COLORSPACE_YCBCR422601_PL: case EVAS_COLORSPACE_YCBCR422601_PL:
if ((rx & 1) || (rw & 1)) if ((rx & 1) || (rw & 1)) return -1;
return -1; if (plane == 0) return ry * ie->w + rx;
if (plane == 0) else if (plane == 1) return (ry * ie->w) / 2 + rx + ie->w * ie->h;
return ry * ie->w + rx;
else if (plane == 1)
return (ry * ie->w) / 2 + rx + ie->w * ie->h;
else return -1; else return -1;
case EVAS_COLORSPACE_YCBCR420NV12601_PL: case EVAS_COLORSPACE_YCBCR420NV12601_PL:
case EVAS_COLORSPACE_YCBCR420TM12601_PL: case EVAS_COLORSPACE_YCBCR420TM12601_PL:
if ((rx & 1) || (ry & 1) || (rw & 1) || (rh & 1)) if ((rx & 1) || (ry & 1) || (rw & 1) || (rh & 1)) return -1;
return -1; if (plane == 0) return ry * ie->w + rx;
if (plane == 0) else if (plane == 1) return (ry * ie->w + rx) / 2 + ie->w * ie->h;
return ry * ie->w + rx;
else if (plane == 1)
return (ry * ie->w + rx) / 2 + ie->w * ie->h;
else return -1; else return -1;
// ETC1/2 RGB, S3TC RGB // ETC1/2 RGB, S3TC RGB
case EVAS_COLORSPACE_ETC1: case EVAS_COLORSPACE_ETC1:
case EVAS_COLORSPACE_RGB8_ETC2: case EVAS_COLORSPACE_RGB8_ETC2:
case EVAS_COLORSPACE_RGB_S3TC_DXT1: case EVAS_COLORSPACE_RGB_S3TC_DXT1:
if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) return -1;
return -1;
return (ry * ie->w + rx) * 8 / 16; return (ry * ie->w + rx) * 8 / 16;
// ETC2 ARGB, S3TC ARGB // ETC2 ARGB, S3TC ARGB
@ -403,16 +376,13 @@ _evas_common_rgba_image_data_offset(int rx, int ry, int rw, int rh, int plane, c
case EVAS_COLORSPACE_RGBA_S3TC_DXT3: case EVAS_COLORSPACE_RGBA_S3TC_DXT3:
case EVAS_COLORSPACE_RGBA_S3TC_DXT4: case EVAS_COLORSPACE_RGBA_S3TC_DXT4:
case EVAS_COLORSPACE_RGBA_S3TC_DXT5: case EVAS_COLORSPACE_RGBA_S3TC_DXT5:
if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) return -1;
return -1;
return (ry * ie->w + rx) * 16 / 16; return (ry * ie->w + rx) * 16 / 16;
// ETC1+Alpha // ETC1+Alpha
case EVAS_COLORSPACE_ETC1_ALPHA: case EVAS_COLORSPACE_ETC1_ALPHA:
if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) if ((rx & 3) || (ry & 3) || (rw & 3) || (rh & 3)) return -1;
return -1; if (plane == 0) return (ry * ie->w + rx) * 8 / 16;
if (plane == 0)
return (ry * ie->w + rx) * 8 / 16;
else if (plane == 1) else if (plane == 1)
return (ry * ie->w + rx) * 8 / 16 + (ie->w * ie->h) * 8 / 16; return (ry * ie->w + rx) * 8 / 16 + (ie->w * ie->h) * 8 / 16;
else return -1; else return -1;
@ -424,8 +394,10 @@ _evas_common_rgba_image_data_offset(int rx, int ry, int rw, int rh, int plane, c
} }
static void * static void *
_evas_common_rgba_image_surface_mmap(Image_Entry *ie, unsigned int w, unsigned int h, _evas_common_rgba_image_surface_mmap(Image_Entry *ie,
/* inout */ int *pl, int *pr, int *pt, int *pb) unsigned int w, unsigned int h,
/*inout*/int *pl, int *pr,
int *pt, int *pb)
{ {
int siz; int siz;
#if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32)) #if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32))
@ -438,11 +410,9 @@ _evas_common_rgba_image_surface_mmap(Image_Entry *ie, unsigned int w, unsigned i
#ifndef MAP_HUGETLB #ifndef MAP_HUGETLB
# define MAP_HUGETLB 0 # define MAP_HUGETLB 0
#endif #endif
if (siz < 0) if (siz < 0) return NULL;
return NULL;
if ((siz < PAGE_SIZE) || evas_image_no_mmap) if ((siz < PAGE_SIZE) || evas_image_no_mmap) return malloc(siz);
return malloc(siz);
if (siz > ((HUGE_PAGE_SIZE * 75) / 100)) if (siz > ((HUGE_PAGE_SIZE * 75) / 100))
r = mmap(NULL, siz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_HUGETLB, -1, 0); r = mmap(NULL, siz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_HUGETLB, -1, 0);
@ -464,11 +434,10 @@ evas_common_rgba_image_surface_munmap(void *data, unsigned int w, unsigned int h
#if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32)) #if defined (HAVE_SYS_MMAN_H) && (!defined (_WIN32))
size_t siz; size_t siz;
siz = _evas_common_rgba_image_surface_size(w, h, cspace, NULL, NULL, NULL, NULL); siz = _evas_common_rgba_image_surface_size(w, h, cspace,
if ((siz < PAGE_SIZE) || evas_image_no_mmap) NULL, NULL, NULL, NULL);
free(data); if ((siz < PAGE_SIZE) || evas_image_no_mmap) free(data);
else else munmap(data, siz);
munmap(data, siz);
#else #else
(void)w; (void)w;
(void)h; (void)h;
@ -480,14 +449,11 @@ evas_common_rgba_image_surface_munmap(void *data, unsigned int w, unsigned int h
EAPI void EAPI void
evas_common_image_init(void) evas_common_image_init(void)
{ {
if (!eci) if (!eci) eci = evas_cache_image_init(&_evas_common_image_func);
eci = evas_cache_image_init(&_evas_common_image_func);
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
if (!eci2) if (!eci2) eci2 = evas_cache2_init(&_evas_common_image_func2);
eci2 = evas_cache2_init(&_evas_common_image_func2);
#endif #endif
reference++; reference++;
//// ERR("REF++=%i", reference);
evas_common_scalecache_init(); evas_common_scalecache_init();
} }
@ -520,7 +486,6 @@ evas_common_image_shutdown(void)
eci2 = NULL; eci2 = NULL;
#endif #endif
} }
evas_common_scalecache_shutdown(); evas_common_scalecache_shutdown();
} }
@ -541,7 +506,6 @@ _evas_common_rgba_image_new(void)
im->flags = RGBA_IMAGE_NOTHING; im->flags = RGBA_IMAGE_NOTHING;
evas_common_rgba_image_scalecache_init(&im->cache_entry); evas_common_rgba_image_scalecache_init(&im->cache_entry);
return &im->cache_entry; return &im->cache_entry;
} }
@ -569,7 +533,6 @@ _evas_common_rgba_image_delete(Image_Entry *ie)
if (ie->data1) if (ie->data1)
ERR("Shouldn't reach this point since we are using cache2: '%s' '%s'", ERR("Shouldn't reach this point since we are using cache2: '%s' '%s'",
ie->file, ie->key); ie->file, ie->key);
// if (ie->data1) evas_cserve2_image_free(ie);
#endif #endif
if (ie->animated.frames) if (ie->animated.frames)
@ -611,11 +574,6 @@ evas_common_rgba_image_unload_real(Image_Entry *ie)
if (ie->data1) if (ie->data1)
{ {
ERR("Shouldn't reach this point since we are using cache2."); ERR("Shouldn't reach this point since we are using cache2.");
// evas_cserve2_image_unload(ie);
// im->image.data = NULL;
// ie->allocated.w = 0;
// ie->allocated.h = 0;
// ie->flags.loaded = 0;
ie->flags.preload_done = 0; ie->flags.preload_done = 0;
return; return;
} }
@ -764,7 +722,8 @@ _evas_common_rgba_image_post_surface(Image_Entry *ie)
} }
static int static int
_evas_common_rgba_image_surface_alloc(Image_Entry *ie, unsigned int w, unsigned int h) _evas_common_rgba_image_surface_alloc(Image_Entry *ie,
unsigned int w, unsigned int h)
{ {
RGBA_Image *im = (RGBA_Image *) ie; RGBA_Image *im = (RGBA_Image *) ie;
int l = 0, r = 0, t = 0, b = 0; int l = 0, r = 0, t = 0, b = 0;
@ -789,7 +748,8 @@ _evas_common_rgba_image_surface_alloc(Image_Entry *ie, unsigned int w, unsigned
r = ie->borders.r; r = ie->borders.r;
t = ie->borders.t; t = ie->borders.t;
b = ie->borders.b; b = ie->borders.b;
im->image.data = _evas_common_rgba_image_surface_mmap(ie, w, h, &l, &r, &t, &b); im->image.data = _evas_common_rgba_image_surface_mmap(ie, w, h,
&l, &r, &t, &b);
if (!im->image.data) return -1; if (!im->image.data) return -1;
ie->borders.l = l; ie->borders.l = l;
ie->borders.r = r; ie->borders.r = r;
@ -832,8 +792,7 @@ _evas_common_rgba_image_surface_delete(Image_Entry *ie)
} }
# endif # endif
#endif #endif
if (ie->file) if (ie->file) DBG("unload: [%p] %s %s", ie, ie->file, ie->key);
DBG("unload: [%p] %s %s", ie, ie->file, ie->key);
if ((im->cs.data) && (im->image.data)) if ((im->cs.data) && (im->image.data))
{ {
if (im->cs.data != im->image.data) if (im->cs.data != im->image.data)
@ -856,11 +815,6 @@ _evas_common_rgba_image_surface_delete(Image_Entry *ie)
surfs = eina_list_remove(surfs, ie); surfs = eina_list_remove(surfs, ie);
#endif #endif
} }
// #ifdef EVAS_CSERVE2
// else if (ie->data1)
// ERR("Shouldn't reach this point since we are using cache2.");
// // evas_cserve2_image_free(ie);
// #endif
im->image.data = NULL; im->image.data = NULL;
ie->allocated.w = 0; ie->allocated.w = 0;
@ -876,18 +830,20 @@ _evas_common_rgba_image_surface_delete(Image_Entry *ie)
static void static void
_evas_common_rgba_image_unload(Image_Entry *im) _evas_common_rgba_image_unload(Image_Entry *im)
{ {
// DBG("unload: [%p] %s %s", im, im->file, im->key);
evas_common_rgba_image_scalecache_dirty(im); evas_common_rgba_image_scalecache_dirty(im);
evas_common_rgba_image_unload(im); evas_common_rgba_image_unload(im);
} }
static void static void
_evas_common_rgba_image_dirty_region(Image_Entry* ie, unsigned int x EINA_UNUSED, unsigned int y EINA_UNUSED, unsigned int w EINA_UNUSED, unsigned int h EINA_UNUSED) _evas_common_rgba_image_dirty_region(Image_Entry* ie,
unsigned int x EINA_UNUSED,
unsigned int y EINA_UNUSED,
unsigned int w EINA_UNUSED,
unsigned int h EINA_UNUSED)
{ {
RGBA_Image *im = (RGBA_Image *) ie; RGBA_Image *im = (RGBA_Image *) ie;
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
// if (ie->data1) evas_cserve2_image_free(ie);
if (ie->data1) ERR("Shouldn't reach this point since we are using cache2."); if (ie->data1) ERR("Shouldn't reach this point since we are using cache2.");
#endif #endif
im->flags |= RGBA_IMAGE_IS_DIRTY; im->flags |= RGBA_IMAGE_IS_DIRTY;
@ -907,24 +863,22 @@ _evas_common_rgba_image_dirty(Image_Entry *ie_dst, const Image_Entry *ie_src)
if (!evas_cache_image_pixels(ie_dst)) if (!evas_cache_image_pixels(ie_dst))
{ {
if (_evas_common_rgba_image_surface_alloc(&dst->cache_entry, if (_evas_common_rgba_image_surface_alloc(&dst->cache_entry,
src->cache_entry.w, src->cache_entry.h)) src->cache_entry.w,
src->cache_entry.h))
{ {
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
// if (ie_src->data1) evas_cserve2_image_free((Image_Entry*) ie_src); if (ie_src->data1)
if (ie_src->data1) ERR("Shouldn't reach this point since we are using cache2."); ERR("Shouldn't reach this point since we are using cache2.");
#endif #endif
return 1; return 1;
} }
} }
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
// if (ie_src->data1) evas_cserve2_image_free((Image_Entry*) ie_src); if (ie_src->data1)
if (ie_src->data1) ERR("Shouldn't reach this point since we are using cache2."); ERR("Shouldn't reach this point since we are using cache2.");
#endif #endif
evas_common_image_colorspace_normalize(src); evas_common_image_colorspace_normalize(src);
evas_common_image_colorspace_normalize(dst); evas_common_image_colorspace_normalize(dst);
/* evas_common_blit_rectangle(src, dst, 0, 0, src->cache_entry.w, src->cache_entry.h, 0, 0); */
/* evas_common_cpu_end_opt(); */
return 0; return 0;
} }
@ -955,86 +909,9 @@ static DATA32 *
_evas_common_rgba_image_surface_pixels(Image_Entry *ie) _evas_common_rgba_image_surface_pixels(Image_Entry *ie)
{ {
RGBA_Image *im = (RGBA_Image *)ie; RGBA_Image *im = (RGBA_Image *)ie;
return im->image.data; return im->image.data;
} }
#if 0
void
evas_common_image_surface_alpha_tiles_calc(RGBA_Surface *is, int tsize)
{
int x, y;
DATA32 *ptr;
if (is->spans) return;
if (!is->im->cache_entry.flags.alpha) return;
/* FIXME: dont handle alpha only images yet */
if (is->im->space != EVAS_COLORSPACE_GRY8) return;
if (tsize < 0) tsize = 0;
is->spans = calloc(1, sizeof(RGBA_Image_Span *) * is->h);
if (!is->spans) return;
ptr = is->data;
for (y = 0; y < is->h; y++)
{
RGBA_Image_Span *sp;
sp = NULL;
for (x = 0; x < is->w; x++)
{
DATA8 a;
a = A_VAL(ptr);
if (sp)
{
if (a == 0)
{
is->spans[y] = eina_inlist_append(is->spans[y], sp);
sp = NULL;
}
else
{
sp->w++;
if ((sp->v == 2) && (a != 255)) sp->v = 1;
}
}
else
{
if (a == 255)
{
sp = calloc(1, sizeof(RGBA_Image_Span));
sp->x = x;
sp->w = 1;
sp->v = 2;
}
else if (a > 0)
{
sp = calloc(1, sizeof(RGBA_Image_Span));
sp->x = x;
sp->w = 1;
sp->v = 1;
}
}
ptr++;
}
if (sp)
{
is->spans[y] = eina_inlist_append(is->spans[y], sp);
sp = NULL;
}
}
}
#endif
/* EAPI void */
/* evas_common_image_surface_dealloc(RGBA_Surface *is) */
/* { */
/* if ((is->data) && (!is->no_free)) */
/* { */
/* free(is->data); */
/* is->data = NULL; */
/* } */
/* } */
static RGBA_Image * static RGBA_Image *
evas_common_image_create(unsigned int w, unsigned int h) evas_common_image_create(unsigned int w, unsigned int h)
{ {
@ -1075,8 +952,7 @@ evas_common_image_alpha_create(unsigned int w, unsigned int h)
EAPI RGBA_Image * EAPI RGBA_Image *
evas_common_image_new(unsigned int w, unsigned int h, unsigned int alpha) evas_common_image_new(unsigned int w, unsigned int h, unsigned int alpha)
{ {
if (alpha) if (alpha) return evas_common_image_alpha_create(w, h);
return evas_common_image_alpha_create(w, h);
return evas_common_image_create(w, h); return evas_common_image_create(w, h);
} }
@ -1093,12 +969,13 @@ evas_common_image_colorspace_normalize(RGBA_Image *im)
if (im->image.data != im->cs.data) if (im->image.data != im->cs.data)
{ {
#ifdef EVAS_CSERVE2 #ifdef EVAS_CSERVE2
// if (((Image_Entry *)im)->data1) evas_cserve2_image_free(&im->cache_entry); if (((Image_Entry *)im)->data1)
if (((Image_Entry *)im)->data1) ERR("Shouldn't reach this point since we are using cache2."); ERR("Shouldn't reach this point since we are using cache2.");
#endif #endif
if (!im->image.no_free) if (!im->image.no_free)
{ {
evas_common_rgba_image_surface_munmap(im->image.data, evas_common_rgba_image_surface_munmap
(im->image.data,
im->cache_entry.allocated.w, im->cache_entry.allocated.w,
im->cache_entry.allocated.h, im->cache_entry.allocated.h,
im->cache_entry.space); im->cache_entry.space);
@ -1114,28 +991,38 @@ evas_common_image_colorspace_normalize(RGBA_Image *im)
break; break;
case EVAS_COLORSPACE_YCBCR422P601_PL: case EVAS_COLORSPACE_YCBCR422P601_PL:
if ((im->image.data) && (*((unsigned char **)im->cs.data))) if ((im->image.data) && (*((unsigned char **)im->cs.data)))
evas_common_convert_yuv_422p_601_rgba(im->cs.data, (DATA8*) im->image.data, evas_common_convert_yuv_422p_601_rgba(im->cs.data,
im->cache_entry.w, im->cache_entry.h); (DATA8 *)im->image.data,
im->cache_entry.w,
im->cache_entry.h);
break; break;
case EVAS_COLORSPACE_YCBCR422601_PL: case EVAS_COLORSPACE_YCBCR422601_PL:
if ((im->image.data) && (*((unsigned char **)im->cs.data))) if ((im->image.data) && (*((unsigned char **)im->cs.data)))
evas_common_convert_yuv_422_601_rgba(im->cs.data, (DATA8*) im->image.data, evas_common_convert_yuv_422_601_rgba(im->cs.data,
im->cache_entry.w, im->cache_entry.h); (DATA8 *)im->image.data,
im->cache_entry.w,
im->cache_entry.h);
break; break;
case EVAS_COLORSPACE_YCBCR420NV12601_PL: case EVAS_COLORSPACE_YCBCR420NV12601_PL:
if ((im->image.data) && (*((unsigned char **)im->cs.data))) if ((im->image.data) && (*((unsigned char **)im->cs.data)))
evas_common_convert_yuv_420_601_rgba(im->cs.data, (DATA8*) im->image.data, evas_common_convert_yuv_420_601_rgba(im->cs.data,
im->cache_entry.w, im->cache_entry.h); (DATA8 *)im->image.data,
im->cache_entry.w,
im->cache_entry.h);
break; break;
case EVAS_COLORSPACE_YCBCR420TM12601_PL: case EVAS_COLORSPACE_YCBCR420TM12601_PL:
if ((im->image.data) && (*((unsigned char **)im->cs.data))) if ((im->image.data) && (*((unsigned char **)im->cs.data)))
evas_common_convert_yuv_420T_601_rgba(im->cs.data, (DATA8*) im->image.data, evas_common_convert_yuv_420T_601_rgba(im->cs.data,
im->cache_entry.w, im->cache_entry.h); (DATA8 *)im->image.data,
im->cache_entry.w,
im->cache_entry.h);
break; break;
case EMILE_COLORSPACE_YCBCR422P709_PL: case EMILE_COLORSPACE_YCBCR422P709_PL:
if ((im->image.data) && (*((unsigned char **)im->cs.data))) if ((im->image.data) && (*((unsigned char **)im->cs.data)))
evas_common_convert_yuv_422p_709_rgba(im->cs.data, (DATA8*) im->image.data, evas_common_convert_yuv_422p_709_rgba(im->cs.data,
im->cache_entry.w, im->cache_entry.h); (DATA8 *)im->image.data,
im->cache_entry.w,
im->cache_entry.h);
break; break;
default: default:
break; break;
@ -1181,7 +1068,8 @@ evas_common_image_get_cache(void)
} }
EAPI RGBA_Image * EAPI RGBA_Image *
evas_common_load_image_from_file(const char *file, const char *key, Evas_Image_Load_Opts *lo, int *error) evas_common_load_image_from_file(const char *file, const char *key,
Evas_Image_Load_Opts *lo, int *error)
{ {
if (!file) if (!file)
{ {
@ -1192,7 +1080,8 @@ evas_common_load_image_from_file(const char *file, const char *key, Evas_Image_L
} }
EAPI RGBA_Image * EAPI RGBA_Image *
evas_common_load_image_from_mmap(Eina_File *f, const char *key, Evas_Image_Load_Opts *lo, int *error) evas_common_load_image_from_mmap(Eina_File *f, const char *key,
Evas_Image_Load_Opts *lo, int *error)
{ {
if (!f) if (!f)
{ {
@ -1229,56 +1118,18 @@ evas_common_image_line_buffer_obtain(int len)
if (len < EVAS_RGBA_LINE_BUFFER_MIN_LEN) if (len < EVAS_RGBA_LINE_BUFFER_MIN_LEN)
len = EVAS_RGBA_LINE_BUFFER_MIN_LEN; len = EVAS_RGBA_LINE_BUFFER_MIN_LEN;
return evas_common_image_create(len, 1); return evas_common_image_create(len, 1);
/*
if (evas_rgba_line_buffer)
{
if (evas_rgba_line_buffer->image->w >= len)
return evas_rgba_line_buffer;
evas_rgba_line_buffer->image->data = (DATA32 *)realloc(evas_rgba_line_buffer->image->data, len * sizeof(DATA32));
if (!evas_rgba_line_buffer->image->data)
{
evas_common_image_free(evas_rgba_line_buffer);
evas_rgba_line_buffer = NULL;
return NULL;
}
evas_rgba_line_buffer->image->w = len;
return evas_rgba_line_buffer;
}
evas_rgba_line_buffer = evas_common_image_create(len, 1);
if (!evas_rgba_line_buffer) return NULL;
return evas_rgba_line_buffer;
*/
} }
EAPI void EAPI void
evas_common_image_line_buffer_release(RGBA_Image *im) evas_common_image_line_buffer_release(RGBA_Image *im)
{ {
_evas_common_rgba_image_delete(&im->cache_entry); _evas_common_rgba_image_delete(&im->cache_entry);
/*
if (!evas_rgba_line_buffer) return;
if (EVAS_RGBA_LINE_BUFFER_MAX_LEN < evas_rgba_line_buffer->image->w)
{
evas_rgba_line_buffer->image->w = EVAS_RGBA_LINE_BUFFER_MAX_LEN;
evas_rgba_line_buffer->image->data = (DATA32 *)realloc(evas_rgba_line_buffer->image->data,
evas_rgba_line_buffer->image->w * sizeof(DATA32));
if (!evas_rgba_line_buffer->image->data)
{
evas_common_image_free(evas_rgba_line_buffer);
evas_rgba_line_buffer = NULL;
}
}
*/
} }
EAPI void EAPI void
evas_common_image_line_buffer_free(RGBA_Image *im) evas_common_image_line_buffer_free(RGBA_Image *im)
{ {
_evas_common_rgba_image_delete(&im->cache_entry); _evas_common_rgba_image_delete(&im->cache_entry);
/*
if (!evas_rgba_line_buffer) return;
evas_common_image_free(evas_rgba_line_buffer);
evas_rgba_line_buffer = NULL;
*/
} }
EAPI RGBA_Image * EAPI RGBA_Image *
@ -1288,44 +1139,12 @@ evas_common_image_alpha_line_buffer_obtain(int len)
if (len < EVAS_ALPHA_LINE_BUFFER_MIN_LEN) if (len < EVAS_ALPHA_LINE_BUFFER_MIN_LEN)
len = EVAS_ALPHA_LINE_BUFFER_MIN_LEN; len = EVAS_ALPHA_LINE_BUFFER_MIN_LEN;
return evas_common_image_alpha_create(len, 1); return evas_common_image_alpha_create(len, 1);
/*
if (evas_alpha_line_buffer)
{
if (evas_alpha_line_buffer->image->w >= len)
return evas_alpha_line_buffer;
evas_alpha_line_buffer->image->data = realloc(evas_alpha_line_buffer->image->data, len * sizeof(DATA8));
if (!evas_alpha_line_buffer->image->data)
{
evas_common_image_free(evas_alpha_line_buffer);
evas_alpha_line_buffer = NULL;
return NULL;
}
evas_alpha_line_buffer->image->w = len;
return evas_alpha_line_buffer;
}
evas_alpha_line_buffer = evas_common_image_alpha_create(len, 1);
return evas_alpha_line_buffer;
*/
} }
EAPI void EAPI void
evas_common_image_alpha_line_buffer_release(RGBA_Image *im) evas_common_image_alpha_line_buffer_release(RGBA_Image *im)
{ {
_evas_common_rgba_image_delete(&im->cache_entry); _evas_common_rgba_image_delete(&im->cache_entry);
/*
if (!evas_alpha_line_buffer) return;
if (EVAS_ALPHA_LINE_BUFFER_MAX_LEN < evas_alpha_line_buffer->image->w)
{
evas_alpha_line_buffer->image->w = EVAS_ALPHA_LINE_BUFFER_MAX_LEN;
evas_alpha_line_buffer->image->data = realloc(evas_alpha_line_buffer->image->data,
evas_alpha_line_buffer->image->w * sizeof(DATA8));
if (!evas_alpha_line_buffer->image->data)
{
evas_common_image_free(evas_alpha_line_buffer);
evas_alpha_line_buffer = NULL;
}
}
*/
} }
EAPI void EAPI void
@ -1340,10 +1159,12 @@ evas_common_image_premul(Image_Entry *ie)
switch (ie->space) switch (ie->space)
{ {
case EVAS_COLORSPACE_ARGB8888: case EVAS_COLORSPACE_ARGB8888:
nas = evas_common_convert_argb_premul(evas_cache_image_pixels(ie), ie->w * ie->h); nas = evas_common_convert_argb_premul
(evas_cache_image_pixels(ie), ie->w * ie->h);
break; break;
case EVAS_COLORSPACE_AGRY88: case EVAS_COLORSPACE_AGRY88:
nas = evas_common_convert_ag_premul((void*) evas_cache_image_pixels(ie), ie->w * ie->h); nas = evas_common_convert_ag_premul
((void *)evas_cache_image_pixels(ie), ie->w * ie->h);
default: return; default: return;
} }
if ((ALPHA_SPARSE_INV_FRACTION * nas) >= (ie->w * ie->h)) if ((ALPHA_SPARSE_INV_FRACTION * nas) >= (ie->w * ie->h))
@ -1366,8 +1187,7 @@ evas_common_image_set_alpha_sparse(Image_Entry *ie)
{ {
DATA32 p = *s & 0xff000000; DATA32 p = *s & 0xff000000;
if (!p || (p == 0xff000000)) if (!p || (p == 0xff000000)) nas++;
nas++;
s++; s++;
} }
if ((ALPHA_SPARSE_INV_FRACTION * nas) >= (ie->w * ie->h)) if ((ALPHA_SPARSE_INV_FRACTION * nas) >= (ie->w * ie->h))