X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/44b376766423858a71312fe61db09fb9160cd1c0..9e90c3a511d4ea403d07522fb41d9f44328ecaa0:/src/mapcache.c diff --git a/src/mapcache.c b/src/mapcache.c index f2c19ba6..55b6f1b7 100644 --- a/src/mapcache.c +++ b/src/mapcache.c @@ -22,14 +22,15 @@ #include "config.h" #endif -#include +#include #include #include #include "globals.h" #include "mapcache.h" #include "preferences.h" +#include "vik_compat.h" -#include "config.h" +#define MC_KEY_SIZE 64 typedef struct _List { struct _List *next; @@ -41,54 +42,75 @@ typedef struct _List { static List *queue_tail = NULL; static int queue_count = 0; -static guint32 queue_size = 0; -static guint32 max_queue_size = VIK_CONFIG_MAPCACHE_SIZE; - +static guint32 cache_size = 0; +static guint32 max_cache_size = VIK_CONFIG_MAPCACHE_SIZE * 1024 * 1024; static GHashTable *cache = NULL; +typedef struct { + GdkPixbuf *pixbuf; + mapcache_extra_t extra; +} cache_item_t; + static GMutex *mc_mutex = NULL; -#define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%.3f-%.3f" -#define HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA "%d-%d-%d-%d-%d-" +#define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%d-%.3f-%.3f" +#define HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA "%d-%d-%d-%d-%d-%d-" +#define HASHKEY_FORMAT_STRING_TYPE "%d-" static VikLayerParamScale params_scales[] = { /* min, max, step, digits (decimal places) */ - { 1, 300, 1, 0 }, + { 1, 1024, 1, 0 }, }; static VikLayerParam prefs[] = { - { VIKING_PREFERENCES_NAMESPACE "mapcache_size", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Mapcache memory size (MB):"), VIK_LAYER_WIDGET_HSCALE, params_scales, NULL }, + { VIK_LAYER_NUM_TYPES, VIKING_PREFERENCES_NAMESPACE "mapcache_size", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Map cache memory size (MB):"), VIK_LAYER_WIDGET_HSCALE, params_scales, NULL, NULL, NULL, NULL, NULL }, }; +static void cache_item_free (cache_item_t *ci) +{ + g_object_unref ( ci->pixbuf ); + g_free ( ci ); +} + void a_mapcache_init () { VikLayerParamData tmp; - tmp.u = VIK_CONFIG_MAPCACHE_SIZE / 1024 / 1024; + tmp.u = VIK_CONFIG_MAPCACHE_SIZE; a_preferences_register(prefs, tmp, VIKING_PREFERENCES_GROUP_KEY); - mc_mutex = g_mutex_new(); - cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, g_object_unref ); + mc_mutex = vik_mutex_new (); + cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) cache_item_free ); } -static void cache_add(gchar *key, GdkPixbuf *pixbuf) +static void cache_add(gchar *key, GdkPixbuf *pixbuf, mapcache_extra_t extra) { - /* TODO: Check if already exists */ - g_hash_table_insert ( cache, key, pixbuf ); - queue_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf); - queue_size += 100; - queue_count++; + cache_item_t *ci = g_malloc ( sizeof(cache_item_t) ); + ci->pixbuf = pixbuf; + ci->extra = extra; +#if !GLIB_CHECK_VERSION(2,26,0) + // Only later versions of GLib actually return a value for this function + // Annoyingly the documentation doesn't say anything about this interface change :( + if ( g_hash_table_insert ( cache, key, ci ) ) +#else + g_hash_table_insert ( cache, key, ci ); +#endif + { + cache_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf); + // ATM size of 'extra' data hardly worth trying to count (compared to pixbuf sizes) + // Not sure what this 100 represents anyway - probably a guess at an average pixbuf metadata size + cache_size += 100; + } } static void cache_remove(const gchar *key) { - GdkPixbuf *buf = g_hash_table_lookup ( cache, key ); - if (buf) { - queue_size -= gdk_pixbuf_get_rowstride(buf) * gdk_pixbuf_get_height(buf); - queue_size -= 100; - queue_count --; - g_hash_table_remove ( cache, key ); - } + cache_item_t *ci = g_hash_table_lookup ( cache, key ); + if (ci && ci->pixbuf) { + cache_size -= gdk_pixbuf_get_rowstride(ci->pixbuf) * gdk_pixbuf_get_height(ci->pixbuf); + cache_size -= 100; + g_hash_table_remove ( cache, key ); + } } /* returns key from head, adds on newtailkey to tail. */ @@ -106,6 +128,7 @@ static gchar *list_shift () List *oldhead = queue_tail->next; queue_tail->next = queue_tail->next->next; g_free ( oldhead ); + queue_count--; return oldheadkey; } @@ -122,29 +145,31 @@ static void list_add_entry ( gchar *key ) newlist->next = newlist; queue_tail = newlist; } + queue_count++; } -void a_mapcache_add ( GdkPixbuf *pixbuf, gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor ) +void a_mapcache_add ( GdkPixbuf *pixbuf, mapcache_extra_t extra, gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name ) { - gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor ); - static int tmp = 0; + guint nn = name ? g_str_hash ( name ) : 0; + gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor ); g_mutex_lock(mc_mutex); - cache_add(key, pixbuf); + cache_add(key, pixbuf, extra); // TODO: that should be done on preference change only... - max_queue_size = a_preferences_get(VIKING_PREFERENCES_NAMESPACE "mapcache_size")->u * 1024 * 1024; - - if ( queue_size > max_queue_size ) { - gchar *oldkey = list_shift_add_entry ( key ); - cache_remove(oldkey); + max_cache_size = a_preferences_get(VIKING_PREFERENCES_NAMESPACE "mapcache_size")->u * 1024 * 1024; - while ( queue_size > max_queue_size && - (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */ - oldkey = list_shift (); + if ( cache_size > max_cache_size ) { + if ( queue_tail ) { + gchar *oldkey = list_shift_add_entry ( key ); cache_remove(oldkey); - } + while ( cache_size > max_cache_size && + (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */ + oldkey = list_shift (); + cache_remove(oldkey); + } + } /* chop off 'start' etc */ } else { list_add_entry ( key ); @@ -152,34 +177,51 @@ void a_mapcache_add ( GdkPixbuf *pixbuf, gint x, gint y, gint z, guint8 type, gu } g_mutex_unlock(mc_mutex); - if ( (++tmp == 100 )) { g_print("DEBUG: queue count=%d %u\n", queue_count, queue_size ); tmp=0; } + static int tmp = 0; + if ( (++tmp == 100 )) { g_debug("DEBUG: cache count=%d size=%u list count=%d\n", g_hash_table_size(cache), cache_size, queue_count ); tmp=0; } } -GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor ) +GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name ) { - static char key[48]; - g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor ); - return g_hash_table_lookup ( cache, key ); + static char key[MC_KEY_SIZE]; + guint nn = name ? g_str_hash ( name ) : 0; + g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor ); + cache_item_t *ci = g_hash_table_lookup ( cache, key ); + if ( ci ) + return ci->pixbuf; + else + return NULL; } -void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint8 type, guint zoom ) +mapcache_extra_t a_mapcache_get_extra ( gint x, gint y, gint z, guint16 type, gint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor, const gchar* name ) { - char key[40]; - List *loop = queue_tail; - List *tmp; - gint len; + static char key[MC_KEY_SIZE]; + guint nn = name ? g_str_hash ( name ) : 0; + g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, type, x, y, z, zoom, nn, alpha, xshrinkfactor, yshrinkfactor ); + cache_item_t *ci = g_hash_table_lookup ( cache, key ); + if ( ci ) + return ci->extra; + else + return (mapcache_extra_t) { 0.0 }; +} +/** + * Common function to remove cache items for keys starting with the specified string + */ +static void flush_matching ( gchar *str ) +{ if ( queue_tail == NULL ) return; - g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA, x, y, z, type, zoom ); - len = strlen(key); + List *loop = queue_tail; + List *tmp; + gint len = strlen(str); g_mutex_lock(mc_mutex); - /* TODO: check logic here */ do { tmp = loop->next; - if ( strncmp(tmp->key, key, len) == 0 ) + if ( tmp ) { + if ( strncmp(tmp->key, str, len) == 0 ) { cache_remove(tmp->key); if ( tmp == loop ) /* we deleted the last thing in the queue! */ @@ -191,17 +233,30 @@ void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint8 type, } g_free ( tmp ); tmp = NULL; + queue_count--; } else loop = tmp; - + } else + loop = NULL; } while ( loop && (loop != queue_tail || tmp == NULL) ); - /* loop thru list, looking for the one, compare first whatever chars */ - cache_remove(key); + + cache_remove(str); g_mutex_unlock(mc_mutex); } +/** + * Appears this is only used when redownloading tiles (i.e. to invalidate old images) + */ +void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint16 type, gint zoom, const gchar* name ) +{ + char key[MC_KEY_SIZE]; + guint nn = name ? g_str_hash ( name ) : 0; + g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA, type, x, y, z, zoom, nn ); + flush_matching ( key ); +} + void a_mapcache_flush () { List *loop = queue_tail; @@ -225,11 +280,36 @@ void a_mapcache_flush () g_mutex_unlock(mc_mutex); } +/** + * a_mapcache_flush_type: + * @type: Specified map type + * + * Just remove cache items for the specified map type + * i.e. all related xyz+zoom+alpha+etc... + */ +void a_mapcache_flush_type ( guint16 type ) +{ + char key[MC_KEY_SIZE]; + g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_TYPE, type ); + flush_matching ( key ); +} + void a_mapcache_uninit () { g_hash_table_destroy ( cache ); /* free list */ cache = NULL; + vik_mutex_free (mc_mutex); } +// Size of mapcache in memory +gint a_mapcache_get_size () +{ + return cache_size; +} +// Count of items in the mapcache +gint a_mapcache_get_count () +{ + return g_hash_table_size ( cache ); +}