594 lines
13 KiB
C
594 lines
13 KiB
C
|
#include <stdlib.h>
|
||
|
#include <assert.h>
|
||
|
#include <Evas.h>
|
||
|
|
||
|
#include "evas_common.h"
|
||
|
#include "evas_private.h"
|
||
|
|
||
|
EAPI int
|
||
|
evas_cache_image_usage_get(Evas_Cache_Image *cache)
|
||
|
{
|
||
|
assert(cache != NULL);
|
||
|
|
||
|
return cache->usage;
|
||
|
}
|
||
|
|
||
|
EAPI int
|
||
|
evas_cache_image_get(Evas_Cache_Image *cache)
|
||
|
{
|
||
|
assert(cache != NULL);
|
||
|
|
||
|
return cache->limit;
|
||
|
}
|
||
|
|
||
|
EAPI void
|
||
|
evas_cache_image_set(Evas_Cache_Image *cache, int limit)
|
||
|
{
|
||
|
assert(cache != NULL);
|
||
|
|
||
|
cache->limit = limit;
|
||
|
}
|
||
|
|
||
|
EAPI Evas_Cache_Image*
|
||
|
evas_cache_image_init(const Evas_Cache_Image_Func *cb)
|
||
|
{
|
||
|
Evas_Cache_Image* new;
|
||
|
|
||
|
new = malloc(sizeof (Evas_Cache_Image));
|
||
|
if (!new)
|
||
|
return NULL;
|
||
|
|
||
|
new->func = *cb;
|
||
|
|
||
|
new->limit = -1;
|
||
|
new->usage = 0;
|
||
|
|
||
|
new->dirty = NULL;
|
||
|
new->lru = NULL;
|
||
|
new->inactiv = NULL;
|
||
|
new->activ = NULL;
|
||
|
|
||
|
new->references = 1;
|
||
|
|
||
|
return new;
|
||
|
}
|
||
|
|
||
|
static Evas_Bool
|
||
|
_evas_cache_image_free_cb(Evas_Hash *hash, const char *key, void *data, void *fdata)
|
||
|
{
|
||
|
Evas_Cache_Image* cache = fdata;
|
||
|
RGBA_Image* im = data;
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("shutdown-activ", im);
|
||
|
|
||
|
free(im->cache_key);
|
||
|
im->cache_key = NULL;
|
||
|
|
||
|
cache->func.destructor(im);
|
||
|
evas_common_image_delete(im);
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
EAPI void
|
||
|
evas_cache_image_shutdown(Evas_Cache_Image *cache)
|
||
|
{
|
||
|
RGBA_Image* im;
|
||
|
|
||
|
assert(cache != NULL);
|
||
|
cache->references--;
|
||
|
|
||
|
if (cache->references > 0)
|
||
|
return ;
|
||
|
|
||
|
while (cache->lru)
|
||
|
{
|
||
|
im = (RGBA_Image*) cache->lru;
|
||
|
cache->lru = evas_object_list_remove(cache->lru, im);
|
||
|
|
||
|
free(im->cache_key);
|
||
|
im->cache_key = NULL;
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("shutdown-lru", im);
|
||
|
cache->func.destructor(im);
|
||
|
evas_common_image_delete(im);
|
||
|
}
|
||
|
|
||
|
/* This is mad, I am about to destroy image still alive, but we need to prevent leak. */
|
||
|
while (cache->dirty)
|
||
|
{
|
||
|
im = (RGBA_Image*) cache->dirty;
|
||
|
cache->dirty = evas_object_list_remove(cache->dirty, im);
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("shutdown-dirty", im);
|
||
|
cache->func.destructor(im);
|
||
|
evas_common_image_delete(im);
|
||
|
}
|
||
|
|
||
|
evas_hash_foreach(cache->activ, _evas_cache_image_free_cb, cache);
|
||
|
evas_hash_free(cache->activ);
|
||
|
evas_hash_free(cache->inactiv);
|
||
|
|
||
|
free(cache);
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_request(Evas_Cache_Image *cache, const char *file, const char *key, RGBA_Image_Loadopts *lo, int *error)
|
||
|
{
|
||
|
const char* format;
|
||
|
char* hkey;
|
||
|
RGBA_Image* im;
|
||
|
Evas_Image_Load_Opts prevent;
|
||
|
int size;
|
||
|
struct stat st;
|
||
|
|
||
|
assert(cache != NULL);
|
||
|
|
||
|
if (!file && !key) return NULL;
|
||
|
if (!file) return NULL;
|
||
|
if ((!lo) ||
|
||
|
(lo &&
|
||
|
(lo->scale_down_by == 0) &&
|
||
|
(lo->dpi = 0.0) &&
|
||
|
((lo->w == 0) || (lo->h == 0))))
|
||
|
{
|
||
|
lo = &prevent;
|
||
|
if (key)
|
||
|
format = "%s//://%s";
|
||
|
else
|
||
|
format = "%s//://%p";
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (key)
|
||
|
format = "%s//://%s//@/%i/%1.5f/%ix%i";
|
||
|
else
|
||
|
format = "%s//://%p//@/%i/%1.5f/%ix%i";
|
||
|
}
|
||
|
size = strlen(file) + (key ? strlen(key) : 6) + 64;
|
||
|
hkey = alloca(sizeof (char) * size);
|
||
|
snprintf(hkey, size, format, file, key, lo->scale_down_by, lo->dpi, lo->w, lo->h);
|
||
|
|
||
|
if (stat(file, &st) < 0) return NULL;
|
||
|
/* FIXME: Handle timestamp correctly. */
|
||
|
|
||
|
im = evas_hash_find(cache->activ, hkey);
|
||
|
if (im)
|
||
|
goto on_ok;
|
||
|
|
||
|
im = evas_hash_find(cache->inactiv, hkey);
|
||
|
if (im)
|
||
|
{
|
||
|
cache->lru = evas_object_list_remove(cache->lru, im);
|
||
|
cache->inactiv = evas_hash_del(cache->inactiv, hkey, im);
|
||
|
cache->activ = evas_hash_add(cache->activ, hkey, im);
|
||
|
|
||
|
goto on_ok;
|
||
|
}
|
||
|
|
||
|
im = evas_common_image_new();
|
||
|
if (!im)
|
||
|
{
|
||
|
*error = -1;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
im->timestamp = st.st_mtime;
|
||
|
im->laststat = time(NULL);
|
||
|
|
||
|
if (lo) im->load_opts = *lo;
|
||
|
|
||
|
im->info.file = (char *) evas_stringshare_add(file);
|
||
|
if (key) im->info.key = (char *) evas_stringshare_add(key);
|
||
|
|
||
|
*error = cache->func.constructor(im);
|
||
|
if (*error != 0)
|
||
|
{
|
||
|
evas_common_image_delete(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("request", im);
|
||
|
|
||
|
cache->activ = evas_hash_add(cache->activ, hkey, im);
|
||
|
|
||
|
im->references = 0;
|
||
|
im->cache_key = strdup(hkey);
|
||
|
im->cache = cache;
|
||
|
|
||
|
cache->usage += strlen(im->cache_key) + 1 + cache->func.mem_size_get(im);
|
||
|
|
||
|
on_ok:
|
||
|
*error = 0;
|
||
|
im->references++;
|
||
|
return im;
|
||
|
}
|
||
|
|
||
|
EAPI void
|
||
|
evas_cache_image_drop(RGBA_Image *im)
|
||
|
{
|
||
|
Evas_Cache_Image* cache;
|
||
|
char* hkey;
|
||
|
|
||
|
assert(im);
|
||
|
assert(im->cache);
|
||
|
|
||
|
im->references--;
|
||
|
cache = im->cache;
|
||
|
|
||
|
if ((im->flags & RGBA_IMAGE_IS_DIRTY) == RGBA_IMAGE_IS_DIRTY)
|
||
|
{
|
||
|
int size;
|
||
|
|
||
|
size = cache->func.mem_size_get(im);
|
||
|
cache->usage -= size;
|
||
|
cache->dirty = evas_object_list_remove(cache->dirty, im);
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("drop", im);
|
||
|
|
||
|
cache->func.destructor(im);
|
||
|
evas_common_image_delete(im);
|
||
|
|
||
|
return ;
|
||
|
}
|
||
|
|
||
|
if (im->references == 0)
|
||
|
{
|
||
|
hkey = im->cache_key;
|
||
|
|
||
|
cache->activ = evas_hash_del(cache->activ, hkey, im);
|
||
|
cache->inactiv = evas_hash_add(cache->inactiv, hkey, im);
|
||
|
cache->lru = evas_object_list_prepend(cache->lru, im);
|
||
|
|
||
|
/* FIXME: Enforce cache limit. */
|
||
|
}
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_dirty(RGBA_Image *im, int x, int y, int w, int h)
|
||
|
{
|
||
|
RGBA_Image* im_dirty = im;
|
||
|
Evas_Cache_Image* cache;
|
||
|
char* hkey;
|
||
|
|
||
|
assert(im);
|
||
|
assert(im->cache);
|
||
|
|
||
|
cache = im->cache;
|
||
|
if (!(im->flags & RGBA_IMAGE_IS_DIRTY))
|
||
|
{
|
||
|
if (im->references == 1)
|
||
|
{
|
||
|
hkey = im->cache_key;
|
||
|
cache->activ = evas_hash_del(cache->activ, hkey, im);
|
||
|
|
||
|
cache->usage -= strlen(hkey) + 1;
|
||
|
|
||
|
free(hkey);
|
||
|
|
||
|
im_dirty = im;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int error;
|
||
|
|
||
|
im_dirty = evas_common_image_new();
|
||
|
if (!im_dirty) goto on_error;
|
||
|
im_dirty->image = evas_common_image_surface_new(im);
|
||
|
if (!im_dirty->image) goto on_error;
|
||
|
im_dirty->image->w = w;
|
||
|
im_dirty->image->h = h;
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("dirty-src", im);
|
||
|
error = cache->func.dirty(im_dirty, im);
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("dirty-out", im_dirty);
|
||
|
|
||
|
if (error != 0) goto on_error;
|
||
|
|
||
|
im_dirty->cache = cache;
|
||
|
im_dirty->references = 1;
|
||
|
|
||
|
cache->usage += cache->func.mem_size_get(im_dirty);
|
||
|
|
||
|
evas_cache_image_drop(im);
|
||
|
}
|
||
|
|
||
|
im_dirty->cache_key = NULL;
|
||
|
im_dirty->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, im_dirty);
|
||
|
}
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("dirty-region", im_dirty);
|
||
|
if (cache->func.dirty_region)
|
||
|
cache->func.dirty_region(im_dirty, x, y, w, h);
|
||
|
|
||
|
return im_dirty;
|
||
|
|
||
|
on_error:
|
||
|
if (im_dirty) evas_common_image_delete(im_dirty);
|
||
|
evas_cache_image_drop(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_alone(RGBA_Image *im)
|
||
|
{
|
||
|
RGBA_Image* im_dirty = im;
|
||
|
Evas_Cache_Image* cache;
|
||
|
char* hkey;
|
||
|
|
||
|
assert(im);
|
||
|
assert(im->cache);
|
||
|
|
||
|
cache = im->cache;
|
||
|
if (im->references == 1)
|
||
|
{
|
||
|
if (!(im->flags & RGBA_IMAGE_IS_DIRTY))
|
||
|
{
|
||
|
hkey = im->cache_key;
|
||
|
cache->activ = evas_hash_del(cache->activ, hkey, im);
|
||
|
|
||
|
cache->usage -= strlen(hkey) + 1;
|
||
|
free(hkey);
|
||
|
|
||
|
im_dirty->cache_key = NULL;
|
||
|
im_dirty->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, im_dirty);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int error;
|
||
|
|
||
|
im_dirty = evas_common_image_new();
|
||
|
if (!im_dirty) goto on_error;
|
||
|
im_dirty->image = evas_common_image_surface_new(im);
|
||
|
if (!im_dirty->image) goto on_error;
|
||
|
im_dirty->image->w = im->image->w;
|
||
|
im_dirty->image->h = im->image->h;
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("dirty-src", im);
|
||
|
error = cache->func.dirty(im_dirty, im);
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("dirty-out", im_dirty);
|
||
|
|
||
|
if (error != 0) goto on_error;
|
||
|
|
||
|
im_dirty->cache_key = NULL;
|
||
|
im_dirty->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
im_dirty->references = 1;
|
||
|
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, im_dirty);
|
||
|
|
||
|
evas_cache_image_drop(im);
|
||
|
}
|
||
|
|
||
|
return im_dirty;
|
||
|
|
||
|
on_error:
|
||
|
if (im_dirty) evas_common_image_delete(im_dirty);
|
||
|
evas_cache_image_drop(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
static RGBA_Image*
|
||
|
_evas_cache_image_push_dirty(Evas_Cache_Image *cache, RGBA_Image* im)
|
||
|
{
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, im);
|
||
|
|
||
|
im->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
im->cache_key = NULL;
|
||
|
im->cache = cache;
|
||
|
|
||
|
return im;
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_copied_data(Evas_Cache_Image *cache, int w, int h, DATA32 *image_data, int alpha, int cspace)
|
||
|
{
|
||
|
RGBA_Image* im;
|
||
|
|
||
|
assert(cache);
|
||
|
|
||
|
if (cspace != EVAS_COLORSPACE_ARGB8888)
|
||
|
w &= ~0x1;
|
||
|
|
||
|
im = evas_common_image_create(w, h);
|
||
|
if (!im) return NULL;
|
||
|
|
||
|
if (cache->func.copied_data(im, w, h, image_data, alpha, cspace) != 0)
|
||
|
{
|
||
|
evas_common_image_delete(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
return _evas_cache_image_push_dirty(cache, im);
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_data(Evas_Cache_Image *cache, int w, int h, DATA32 *image_data, int alpha, int cspace)
|
||
|
{
|
||
|
RGBA_Image* im;
|
||
|
|
||
|
assert(cache);
|
||
|
|
||
|
im = evas_common_image_new();
|
||
|
if (!im) return NULL;
|
||
|
im->image = evas_common_image_surface_new(im);
|
||
|
if (!im->image)
|
||
|
{
|
||
|
evas_common_image_delete(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
if (cache->func.data(im, w, h, image_data, alpha, cspace) != 0)
|
||
|
{
|
||
|
evas_common_image_delete(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
return _evas_cache_image_push_dirty(cache, im);
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_size_set(RGBA_Image *im, int w, int h)
|
||
|
{
|
||
|
Evas_Cache_Image* cache;
|
||
|
RGBA_Image* new;
|
||
|
int error;
|
||
|
|
||
|
assert(im);
|
||
|
assert(im->image);
|
||
|
assert(im->cache);
|
||
|
assert(im->references > 0);
|
||
|
|
||
|
if (im->image->w == w
|
||
|
&& im->image->h == h)
|
||
|
return im;
|
||
|
|
||
|
cache = im->cache;
|
||
|
|
||
|
new = evas_common_image_new();
|
||
|
if (!new) goto on_error;
|
||
|
new->image = evas_common_image_surface_new(im);
|
||
|
if (!new->image) goto on_error;
|
||
|
new->image->w = w;
|
||
|
new->image->h = h;
|
||
|
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("size_set-in", im);
|
||
|
error = cache->func.size_set(new, im, w, h);
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("size_set-out", new);
|
||
|
|
||
|
if (error != 0) goto on_error;
|
||
|
|
||
|
new->cache = cache;
|
||
|
new->cache_key = NULL;
|
||
|
|
||
|
new->references = 1;
|
||
|
cache->usage += cache->func.mem_size_get(new);
|
||
|
|
||
|
if ((im->flags & RGBA_IMAGE_IS_DIRTY) == RGBA_IMAGE_IS_DIRTY
|
||
|
|| im->references > 1)
|
||
|
{
|
||
|
new->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, new);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
char* cache_key = NULL;
|
||
|
|
||
|
cache_key = im->cache_key ? strdup(im->cache_key) : NULL;
|
||
|
new->cache_key = cache_key;
|
||
|
|
||
|
cache->activ = evas_hash_add(cache->activ, cache_key, new);
|
||
|
cache->usage += strlen(new->cache_key) + 1;
|
||
|
}
|
||
|
|
||
|
evas_cache_image_drop(im);
|
||
|
|
||
|
return new;
|
||
|
|
||
|
on_error:
|
||
|
if (new) evas_common_image_delete(new);
|
||
|
evas_cache_image_drop(im);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
EAPI void
|
||
|
evas_cache_image_load_data(RGBA_Image *im)
|
||
|
{
|
||
|
Evas_Cache_Image* cache;
|
||
|
int size;
|
||
|
|
||
|
assert(im);
|
||
|
assert(im->image);
|
||
|
assert(im->cache);
|
||
|
|
||
|
if ((im->flags & RGBA_IMAGE_LOADED) == RGBA_IMAGE_LOADED) return ;
|
||
|
|
||
|
cache = im->cache;
|
||
|
if (cache->func.debug)
|
||
|
cache->func.debug("load", im);
|
||
|
|
||
|
size = cache->func.mem_size_get(im);
|
||
|
cache->func.load(im);
|
||
|
cache->usage += cache->func.mem_size_get(im) - size;
|
||
|
|
||
|
im->flags |= RGBA_IMAGE_LOADED;
|
||
|
|
||
|
assert(im->image->data);
|
||
|
}
|
||
|
|
||
|
EAPI int
|
||
|
evas_cache_image_flush(Evas_Cache_Image *cache)
|
||
|
{
|
||
|
assert(cache);
|
||
|
|
||
|
if (cache->limit == -1)
|
||
|
return -1;
|
||
|
|
||
|
while (cache->lru && cache->limit < cache->usage)
|
||
|
{
|
||
|
RGBA_Image* im;
|
||
|
|
||
|
im = (RGBA_Image*) cache->lru->last;
|
||
|
cache->lru = evas_object_list_remove(cache->lru, im);
|
||
|
cache->inactiv = evas_hash_del(cache->inactiv, im->cache_key, im);
|
||
|
|
||
|
cache->usage -= strlen(im->cache_key) + 1;
|
||
|
cache->usage -= cache->func.mem_size_get(im);
|
||
|
|
||
|
free(im->cache_key);
|
||
|
im->cache_key = NULL;
|
||
|
|
||
|
cache->func.destructor(im);
|
||
|
evas_common_image_delete(im);
|
||
|
}
|
||
|
return cache->usage;
|
||
|
}
|
||
|
|
||
|
EAPI RGBA_Image*
|
||
|
evas_cache_image_empty(Evas_Cache_Image* cache)
|
||
|
{
|
||
|
RGBA_Image* new;
|
||
|
|
||
|
new = evas_common_image_new();
|
||
|
if (!new) goto on_error;
|
||
|
new->image = evas_common_image_surface_new(new);
|
||
|
if (!new->image) goto on_error;
|
||
|
|
||
|
new->cache = cache;
|
||
|
new->references = 1;
|
||
|
|
||
|
new->cache_key = NULL;
|
||
|
new->flags |= RGBA_IMAGE_IS_DIRTY;
|
||
|
|
||
|
cache->dirty = evas_object_list_prepend(cache->dirty, new);
|
||
|
|
||
|
return new;
|
||
|
|
||
|
on_error:
|
||
|
if (new) evas_common_image_delete(new);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
EAPI void
|
||
|
evas_cache_image_colorspace(RGBA_Image* im, int cspace)
|
||
|
{
|
||
|
if (!im) return ;
|
||
|
if (im->cs.space == cspace) return ;
|
||
|
|
||
|
evas_common_image_colorspace_set(im, cspace);
|
||
|
}
|