/*
Copyright (C) 2009-2010 Samsung Electronics
Copyright (C) 2009-2010 ProFUSION embedded systems
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "ewk_tiled_matrix.h"
#define _GNU_SOURCE
#include "ewk_tiled_backing_store.h"
#include "ewk_tiled_private.h"
#include <Eina.h>
#include <errno.h>
#include <inttypes.h>
#include <math.h>
#include <stdio.h> // XXX remove me later
#include <stdlib.h>
#include <string.h>
static const Evas_Coord TILE_MATRIX_BASE_TILE_SIZE = 256;
struct _Ewk_Tile_Matrix {
Eina_Matrixsparse *matrix;
Ewk_Tile_Unused_Cache *tuc;
Evas_Colorspace cspace;
struct {
void (*cb)(void *data, Ewk_Tile *t, const Eina_Rectangle *update);
void *data;
} render;
unsigned int frozen;
Eina_List *updates;
#ifdef DEBUG_MEM_LEAKS
struct {
struct {
uint64_t allocated, freed;
} tiles, bytes;
} stats;
#endif
};
#ifdef DEBUG_MEM_LEAKS
static uint64_t tiles_leaked = 0;
static uint64_t bytes_leaked = 0;
#endif
/* called when matrixsparse is resized or freed */
static void _ewk_tile_matrix_cell_free(void *user_data, void *cell_data)
{
Ewk_Tile_Matrix *tm = user_data;
Eina_Inlist *l = cell_data;
if (!l)
return;
ewk_tile_unused_cache_freeze(tm->tuc);
while (l) {
Ewk_Tile *t = (Ewk_Tile *)l;
l = l->next;
if (t->updates || t->stats.full_update)
tm->updates = eina_list_remove(tm->updates, t);
if (t->visible)
ERR("freeing cell that is visible, leaking tile %p", t);
else {
if (!ewk_tile_unused_cache_tile_get(tm->tuc, t))
ERR("tile %p was not in cache %p? leaking...", t, tm->tuc);
else {
DBG("tile cell does not exist anymore, free it %p", t);
#ifdef DEBUG_MEM_LEAKS
tm->stats.bytes.freed += t->bytes;
tm->stats.tiles.freed++;
#endif
ewk_tile_free(t);
}
}
}
ewk_tile_unused_cache_thaw(tm->tuc);
}
/* called when cache of unused tile is flushed */
static void _ewk_tile_matrix_tile_free(void *data, Ewk_Tile *t)
{
Ewk_Tile_Matrix *tm = data;
Eina_Matrixsparse_Cell *cell;
Eina_Inlist *l, *old;
if (!eina_matrixsparse_cell_idx_get(tm->matrix, t->row, t->col, &cell)) {
ERR("removing tile %p that was not in the matrix? Leaking...", t);
return;
}
if (t->updates || t->stats.full_update)
tm->updates = eina_list_remove(tm->updates, t);
old = eina_matrixsparse_cell_data_get(cell);
l = eina_inlist_remove(old, EINA_INLIST_GET(t));
if (!l) {
/* set to null to avoid double free */
eina_matrixsparse_cell_data_replace(cell, NULL, NULL);
eina_matrixsparse_cell_clear(cell);
} else if (old != l)
eina_matrixsparse_cell_data_replace(cell, l, NULL);
if (EINA_UNLIKELY(!!t->visible)) {
ERR("cache of unused tiles requesting deletion of used tile %p? "
"Leaking...", t);
return;
}
#ifdef DEBUG_MEM_LEAKS
tm->stats.bytes.freed += t->bytes;
tm->stats.tiles.freed++;
#endif
ewk_tile_free(t);
}
/**
* Creates a new matrix of tiles.
*
* The tile matrix is responsible for keeping tiles around and
* providing fast access to them. One can use it to retrieve new or
* existing tiles and give them back, allowing them to be
* freed/replaced by the cache.
*
* @param tuc cache of unused tiles or @c NULL to create one
* automatically.
* @param cols number of columns in the matrix.
* @param rows number of rows in the matrix.
* @param cspace the color space used to create tiles in this matrix.
* @param render_cb function used to render given tile update.
* @param data context to give back to @a render_cb.
*
* @return newly allocated instance on success, @c NULL on failure.
*/
Ewk_Tile_Matrix *ewk_tile_matrix_new(Ewk_Tile_Unused_Cache *tuc, unsigned long cols, unsigned long rows, Evas_Colorspace cspace, void (*render_cb)(void *data, Ewk_Tile *t, const Eina_Rectangle *update), const void *data)
{
Ewk_Tile_Matrix *tm;
CALLOC_OR_OOM_RET(tm, sizeof(Ewk_Tile_Matrix), NULL);
tm->matrix = eina_matrixsparse_new(rows, cols, _ewk_tile_matrix_cell_free, tm);
if (!tm->matrix) {
ERR("could not create sparse matrix.");
free(tm);
return NULL;
}
if (tuc)
tm->tuc = ewk_tile_unused_cache_ref(tuc);
else {
tm->tuc = ewk_tile_unused_cache_new(40960000);
if (!tm->tuc) {
ERR("no cache of unused tile!");
eina_matrixsparse_free(tm->matrix);
free(tm);
return NULL;
}
}
tm->cspace = cspace;
tm->render.cb = render_cb;
tm->render.data = (void *)data;
return tm;
}
/**
* Destroys tiles matrix, releasing its resources.
*
* The cache instance is unreferenced, possibly freeing it.
*/
void ewk_tile_matrix_free(Ewk_Tile_Matrix *tm)
{
#ifdef DEBUG_MEM_LEAKS
uint64_t tiles, bytes;
#endif
EINA_SAFETY_ON_NULL_RETURN(tm);
ewk_tile_unused_cache_freeze(tm->tuc);
eina_matrixsparse_free(tm->matrix);
ewk_tile_unused_cache_thaw(tm->tuc);
ewk_tile_unused_cache_unref(tm->tuc);
#ifdef DEBUG_MEM_LEAKS
tiles = tm->stats.tiles.allocated - tm->stats.tiles.freed;
bytes = tm->stats.bytes.allocated - tm->stats.bytes.freed;
tiles_leaked += tiles;
bytes_leaked += bytes;
if (tiles || bytes)
ERR("tiled matrix leaked: tiles[+%"PRIu64",-%"PRIu64":%"PRIu64"] "
"bytes[+%"PRIu64",-%"PRIu64":%"PRIu64"]",
tm->stats.tiles.allocated, tm->stats.tiles.freed, tiles,
tm->stats.bytes.allocated, tm->stats.bytes.freed, bytes);
else if (tiles_leaked || bytes_leaked)
WRN("tiled matrix had no leaks: tiles[+%"PRIu64",-%"PRIu64"] "
"bytes[+%"PRIu64",-%"PRIu64"], but some other leaked "
"%"PRIu64" tiles (%"PRIu64" bytes)",
tm->stats.tiles.allocated, tm->stats.tiles.freed,
tm->stats.bytes.allocated, tm->stats.bytes.freed,
tiles_leaked, bytes_leaked);
else
INF("tiled matrix had no leaks: tiles[+%"PRIu64",-%"PRIu64"] "
"bytes[+%"PRIu64",-%"PRIu64"]",
tm->stats.tiles.allocated, tm->stats.tiles.freed,
tm->stats.bytes.allocated, tm->stats.bytes.freed);
#endif
free(tm);
}
/**
* Resize matrix to given number of rows and columns.
*/
void ewk_tile_matrix_resize(Ewk_Tile_Matrix *tm, unsigned long cols, unsigned long rows)
{
EINA_SAFETY_ON_NULL_RETURN(tm);
eina_matrixsparse_size_set(tm->matrix, rows, cols);
}
/**
* Get the cache of unused tiles in use by given matrix.
*
* No reference is taken to the cache.
*/
Ewk_Tile_Unused_Cache *ewk_tile_matrix_unused_cache_get(const Ewk_Tile_Matrix *tm)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, NULL);
return tm->tuc;
}
/**
* Get the exact tile for the given position and zoom.
*
* If the tile was unused then it's removed from the cache.
*
* After usage, please give it back using
* ewk_tile_matrix_tile_put(). If you just want to check if it exists,
* then use ewk_tile_matrix_tile_exact_exists().
*
* @param tm the tile matrix to get tile from.
* @param col the column number.
* @param row the row number.
* @param zoom the exact zoom to use.
*
* @return The tile instance or @c NULL if none is found. If the tile
* was in the unused cache it will be @b removed (thus
* considered used) and one should give it back with
* ewk_tile_matrix_tile_put() afterwards.
*
* @see ewk_tile_matrix_tile_nearest_get()
* @see ewk_tile_matrix_tile_exact_get()
*/
Ewk_Tile *ewk_tile_matrix_tile_exact_get(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, float zoom)
{
Ewk_Tile *t, *item, *item_found = NULL;
Eina_Inlist *inl;
t = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!t)
return NULL;
if (t->zoom == zoom)
goto end;
EINA_INLIST_FOREACH(EINA_INLIST_GET(t), item) {
if (item->zoom != zoom)
continue;
item_found = item;
break;
}
if (!item_found)
return NULL;
inl = eina_inlist_promote(EINA_INLIST_GET(t), EINA_INLIST_GET(item_found));
eina_matrixsparse_data_idx_replace(tm->matrix, row, col, inl, NULL);
end:
if (!t->visible) {
if (!ewk_tile_unused_cache_tile_get(tm->tuc, t))
WRN("Ewk_Tile was unused but not in cache? bug!");
}
return t;
}
/**
* Checks if tile of given zoom exists in matrix.
*
* @param tm the tile matrix to check tile existence.
* @param col the column number.
* @param row the row number.
* @param zoom the exact zoom to query.
*
* @return @c EINA_TRUE if found, @c EINA_FALSE otherwise.
*
* @see ewk_tile_matrix_tile_exact_get()
*/
Eina_Bool ewk_tile_matrix_tile_exact_exists(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, float zoom)
{
Ewk_Tile *t, *item;
t = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!t)
return EINA_FALSE;
EINA_INLIST_FOREACH(EINA_INLIST_GET(t), item) {
if (item->zoom == zoom)
return EINA_TRUE;
}
return EINA_FALSE;
}
/**
* Get the nearest tile for given position and zoom.
*
* The nearest tile is the one at the given position but with the
* closest zoom, this being the division of the tile zoom by the
* desired zoom, the closest to 1.0 gets it.
*
* If the tile was unused then it's removed from the cache.
*
* After usage, please give it back using ewk_tile_matrix_tile_put().
*
* @param tm the tile matrix to get tile from.
* @param col the column number.
* @param row the row number.
* @param zoom the exact zoom to use.
*
* @return The tile instance or @c NULL if none is found. If the tile
* was in the unused cache it will be @b removed (thus
* considered used) and one should give it back with
* ewk_tile_matrix_tile_put() afterwards.
*/
Ewk_Tile *ewk_tile_matrix_tile_nearest_get(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, float zoom)
{
Ewk_Tile *t, *item, *item_found = NULL;
Eina_Inlist *inl;
float zoom_found = 0;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(zoom > 0.0, NULL);
t = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!t)
return NULL;
if (t->zoom == zoom) {
item_found = t;
goto end;
}
EINA_INLIST_FOREACH(EINA_INLIST_GET(t), item) {
float cur_zoom = item->zoom;
if (cur_zoom == zoom) {
item_found = item;
break;
}
if (cur_zoom > zoom)
cur_zoom = zoom / cur_zoom;
else
cur_zoom = cur_zoom / zoom;
if (cur_zoom > zoom_found) {
item_found = item;
zoom_found = cur_zoom;
}
}
if (!item_found)
return NULL;
inl = eina_inlist_promote(EINA_INLIST_GET(t), EINA_INLIST_GET(item_found));
eina_matrixsparse_data_idx_replace(tm->matrix, row, col, inl, NULL);
end:
if (!item_found->visible) {
if (!ewk_tile_unused_cache_tile_get(tm->tuc, item_found))
WRN("Ewk_Tile was unused but not in cache? bug!");
}
return item_found;
}
/**
* Create a new tile at given position and zoom level in the matrix.
*
* The newly created tile is considered in use and not put into cache
* of unused tiles. After it is used one should call
* ewk_tile_matrix_tile_put() to give it back to matrix.
*
* @param tm the tile matrix to create tile on.
* @param col the column number.
* @param row the row number.
* @param zoom the level to create tile, used to determine tile size.
*/
Ewk_Tile *ewk_tile_matrix_tile_new(Ewk_Tile_Matrix *tm, Evas *evas, unsigned long col, unsigned int row, float zoom)
{
Evas_Coord s;
Eina_Inlist *old;
Ewk_Tile *t;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(zoom > 0.0, NULL);
s = TILE_SIZE_AT_ZOOM(TILE_MATRIX_BASE_TILE_SIZE, zoom);
zoom = (float)s / (float)TILE_MATRIX_BASE_TILE_SIZE;
t = ewk_tile_new(evas, s, s, zoom, tm->cspace);
if (!t) {
ERR("could not create tile %dx%d at %f, cspace=%d",
s, s, (double)zoom, tm->cspace);
return NULL;
}
old = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
old = eina_inlist_prepend(old, EINA_INLIST_GET(t));
if (!eina_matrixsparse_data_idx_replace(tm->matrix, row, col, t, NULL)) {
ERR("could not set matrix cell, row/col outside matrix dimensions!");
ewk_tile_free(t);
return NULL;
}
t->col = col;
t->row = row;
t->x = col * s;
t->y = row * s;
cairo_translate(t->cairo, -t->x, -t->y);
t->stats.full_update = EINA_TRUE;
tm->updates = eina_list_append(tm->updates, t);
#ifdef DEBUG_MEM_LEAKS
tm->stats.bytes.allocated += t->bytes;
tm->stats.tiles.allocated++;
#endif
return t;
}
/**
* Gives back the tile to the tile matrix.
*
* This will report the tile is no longer in use by the one that got
* it with ewk_tile_matrix_tile_nearest_get() or
* ewk_tile_matrix_tile_exact_get().
*
* Any previous reference to tile should be released
* (ewk_tile_hide()) before calling this function, so it will
* be known if it is not visibile anymore and thus can be put into the
* unused cache.
*
* @param tm the tile matrix to return tile to.
* @param t the tile instance to return, must @b not be @c NULL.
* @param last_used time in which tile was last used.
*
* @return #EINA_TRUE on success or #EINA_FALSE on failure.
*/
Eina_Bool ewk_tile_matrix_tile_put(Ewk_Tile_Matrix *tm, Ewk_Tile *t, double last_used)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(t, EINA_FALSE);
if (t->visible)
return EINA_TRUE;
t->stats.last_used = last_used;
return ewk_tile_unused_cache_tile_put(tm->tuc, t, _ewk_tile_matrix_tile_free, tm);
}
Eina_Bool ewk_tile_matrix_tile_update(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, const Eina_Rectangle *update)
{
Ewk_Tile *l, *t;
Eina_Rectangle new_update;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(update, EINA_FALSE);
memcpy(&new_update, update, sizeof(new_update));
// check update is valid, otherwise return EINA_FALSE
if (update->x < 0 || update->y < 0 || update->w <= 0 || update->h <= 0) {
ERR("invalid update region.");
return EINA_FALSE;
}
if (update->x + update->w - 1 >= TILE_MATRIX_BASE_TILE_SIZE)
new_update.w = TILE_MATRIX_BASE_TILE_SIZE - update->x;
if (update->y + update->h - 1 >= TILE_MATRIX_BASE_TILE_SIZE)
new_update.h = TILE_MATRIX_BASE_TILE_SIZE - update->y;
l = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!l)
return EINA_TRUE;
EINA_INLIST_FOREACH(EINA_INLIST_GET(l), t) {
if (!t->updates && !t->stats.full_update)
tm->updates = eina_list_append(tm->updates, t);
new_update.x = roundf(t->zoom * new_update.x);
new_update.y = roundf(t->zoom * new_update.y);
new_update.w = roundf(t->zoom * new_update.w);
new_update.h = roundf(t->zoom * new_update.h);
ewk_tile_update_area(t, &new_update);
}
return EINA_TRUE;
}
Eina_Bool ewk_tile_matrix_tile_update_full(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row)
{
Ewk_Tile *l, *t;
Eina_Matrixsparse_Cell *cell;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, EINA_FALSE);
if (!eina_matrixsparse_cell_idx_get(tm->matrix, row, col, &cell))
return EINA_FALSE;
if (!cell)
return EINA_TRUE;
l = eina_matrixsparse_cell_data_get(cell);
if (!l) {
CRITICAL("matrix cell with no tile!");
return EINA_TRUE;
}
EINA_INLIST_FOREACH(EINA_INLIST_GET(l), t) {
if (!t->updates && !t->stats.full_update)
tm->updates = eina_list_append(tm->updates, t);
ewk_tile_update_full(t);
}
return EINA_TRUE;
}
void ewk_tile_matrix_tile_updates_clear(Ewk_Tile_Matrix *tm, Ewk_Tile *t)
{
EINA_SAFETY_ON_NULL_RETURN(tm);
if (!t->updates && !t->stats.full_update)
return;
ewk_tile_updates_clear(t);
tm->updates = eina_list_remove(tm->updates, t);
}
static Eina_Bool _ewk_tile_matrix_slicer_setup(Ewk_Tile_Matrix *tm, const Eina_Rectangle *area, float zoom, Eina_Tile_Grid_Slicer *slicer)
{
unsigned long rows, cols;
Evas_Coord x, y, w, h, tw, th;
if (area->w <= 0 || area->h <= 0) {
WRN("invalid area region: %d,%d+%dx%d.",
area->x, area->y, area->w, area->h);
return EINA_FALSE;
}
x = area->x;
y = area->y;
w = area->w;
h = area->h;
tw = TILE_SIZE_AT_ZOOM(TILE_W, zoom);
th = TILE_SIZE_AT_ZOOM(TILE_H, zoom);
// cropping area region to fit matrix
eina_matrixsparse_size_get(tm->matrix, &rows, &cols);
if (x < 0) {
w += x;
x = 0;
}
if (y < 0) {
h += y;
y = 0;
}
if (y + h - 1 > (long)(rows * th))
h = rows * th - y;
if (x + w - 1 > (long)(cols * tw))
w = cols * tw - x;
return eina_tile_grid_slicer_setup(slicer, x, y, w, h, tw, th);
}
Eina_Bool ewk_tile_matrix_update(Ewk_Tile_Matrix *tm, const Eina_Rectangle *update, float zoom)
{
const Eina_Tile_Grid_Info *info;
Eina_Tile_Grid_Slicer slicer;
EINA_SAFETY_ON_NULL_RETURN_VAL(tm, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(update, EINA_FALSE);
if (update->w < 1 || update->h < 1) {
DBG("Why we get updates with empty areas? %d,%d+%dx%d at zoom %f",
update->x, update->y, update->w, update->h, zoom);
return EINA_TRUE;
}
if (!_ewk_tile_matrix_slicer_setup(tm, update, zoom, &slicer)) {
ERR("Could not setup slicer for update %d,%d+%dx%d at zoom %f",
update->x, update->y, update->w, update->h, zoom);
return EINA_FALSE;
}
while (eina_tile_grid_slicer_next(&slicer, &info)) {
unsigned long col, row;
Ewk_Tile *l, *t;
col = info->col;
row = info->row;
l = eina_matrixsparse_data_idx_get(tm->matrix, row, col);
if (!l)
continue;
EINA_INLIST_FOREACH(EINA_INLIST_GET(l), t) {
if (!t->updates && !t->stats.full_update)
tm->updates = eina_list_append(tm->updates, t);
if (info->full)
ewk_tile_update_full(t);
else {
if (t->zoom != zoom)
ewk_tile_update_full(t);
else
ewk_tile_update_area(t, &info->rect);
}
}
}
return EINA_TRUE;
}
void ewk_tile_matrix_updates_process(Ewk_Tile_Matrix *tm)
{
Eina_List *l, *l_next;
Ewk_Tile *t;
EINA_SAFETY_ON_NULL_RETURN(tm);
// process updates, unflag tiles
EINA_LIST_FOREACH_SAFE(tm->updates, l, l_next, t) {
ewk_tile_updates_process(t, tm->render.cb, tm->render.data);
if (t->visible) {
ewk_tile_updates_clear(t);
tm->updates = eina_list_remove_list(tm->updates, l);
}
}
}
void ewk_tile_matrix_updates_clear(Ewk_Tile_Matrix *tm)
{
Ewk_Tile *t;
EINA_SAFETY_ON_NULL_RETURN(tm);
EINA_LIST_FREE(tm->updates, t)
ewk_tile_updates_clear(t);
tm->updates = NULL;
}
// remove me later!
void ewk_tile_matrix_dbg(const Ewk_Tile_Matrix *tm)
{
Eina_Iterator *it = eina_matrixsparse_iterator_complete_new(tm->matrix);
Eina_Matrixsparse_Cell *cell;
Eina_Bool last_empty = EINA_FALSE;
#ifdef DEBUG_MEM_LEAKS
printf("Ewk_Tile Matrix: tiles[+%"PRIu64",-%"PRIu64":%"PRIu64"] "
"bytes[+%"PRIu64",-%"PRIu64":%"PRIu64"]\n",
tm->stats.tiles.allocated, tm->stats.tiles.freed,
tm->stats.tiles.allocated - tm->stats.tiles.freed,
tm->stats.bytes.allocated, tm->stats.bytes.freed,
tm->stats.bytes.allocated - tm->stats.bytes.freed);
#else
printf("Ewk_Tile Matrix:\n");
#endif
EINA_ITERATOR_FOREACH(it, cell) {
unsigned long row, col;
Eina_Inlist *l;
eina_matrixsparse_cell_position_get(cell, &row, &col);
l = eina_matrixsparse_cell_data_get(cell);
if (!l) {
if (!last_empty) {
last_empty = EINA_TRUE;
printf("Empty:");
}
printf(" [%lu,%lu]", col, row);
} else {
if (last_empty) {
last_empty = EINA_FALSE;
printf("\n");
}
Ewk_Tile *t;
printf("%3lu,%3lu %10p:", col, row, l);
EINA_INLIST_FOREACH(l, t)
printf(" [%3lu,%3lu + %dx%d @ %0.3f]%c",
t->col, t->row, t->w, t->h, t->zoom,
t->visible ? '*': ' ');
printf("\n");
}
}
if (last_empty)
printf("\n");
eina_iterator_free(it);
ewk_tile_unused_cache_dbg(tm->tuc);
}
/**
* Freeze matrix to not do maintenance tasks.
*
* Maintenance tasks optimize usage, but maybe we know we should hold
* on them until we do the last operation, in this case we freeze
* while operating and then thaw when we're done.
*
* @see ewk_tile_matrix_thaw()
*/
void ewk_tile_matrix_freeze(Ewk_Tile_Matrix *tm)
{
EINA_SAFETY_ON_NULL_RETURN(tm);
if (!tm->frozen)
ewk_tile_unused_cache_freeze(tm->tuc);
tm->frozen++;
}
/**
* Unfreezes maintenance tasks.
*
* If this is the last counterpart of freeze, then maintenance tasks
* will run immediately.
*/
void ewk_tile_matrix_thaw(Ewk_Tile_Matrix *tm)
{
EINA_SAFETY_ON_NULL_RETURN(tm);
if (!tm->frozen) {
ERR("thawing more than freezing!");
return;
}
tm->frozen--;
if (!tm->frozen)
ewk_tile_unused_cache_thaw(tm->tuc);
}