src/mapcache.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <gtk/gtk.h>
  26 #include <glib/gi18n.h>
  27 #include <string.h>
  28 #include "globals.h"
  29 #include "mapcache.h"
  30 #include "preferences.h"
  31
  32 #include "config.h"
  33
  34 typedef struct _List {
  35   struct _List *next;
  36   gchar *key;
  37 } List;
  38
  39 /* a circular linked list, a pointer to the tail, and the tail points to the head */
  40 /* this is so we can free the last */
  41 static List *queue_tail = NULL;
  42 static int queue_count = 0;
  43
  44 static guint32 queue_size = 0;
  45 static guint32 max_queue_size = VIK_CONFIG_MAPCACHE_SIZE;
  46
  47
  48 static GHashTable *cache = NULL;
  49
  50 static GMutex *mc_mutex = NULL;
  51
  52 #define HASHKEY_FORMAT_STRING "%d-%d-%d-%d-%d-%d-%.3f-%.3f"
  53 #define HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA "%d-%d-%d-%d-%d-"
  54
  55 static VikLayerParamScale params_scales[] = {
  56   /* min, max, step, digits (decimal places) */
  57  { 1, 300, 1, 0 },
  58 };
  59
  60 static VikLayerParam prefs[] = {
  61   { 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 },
  62 };
  63
  64 void a_mapcache_init ()
  65 {
  66   VikLayerParamData tmp;
  67   tmp.u = VIK_CONFIG_MAPCACHE_SIZE / 1024 / 1024;
  68   a_preferences_register(prefs, tmp, VIKING_PREFERENCES_GROUP_KEY);
  69
  70   mc_mutex = g_mutex_new();
  71   cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, g_object_unref );
  72 }
  73
  74 static void cache_add(gchar *key, GdkPixbuf *pixbuf)
  75 {
  76   /* TODO: Check if already exists */
  77   g_hash_table_insert ( cache, key, pixbuf );
  78   queue_size += gdk_pixbuf_get_rowstride(pixbuf) * gdk_pixbuf_get_height(pixbuf);
  79   queue_size += 100;
  80   queue_count++;
  81 }
  82
  83 static void cache_remove(const gchar *key)
  84 {
  85     GdkPixbuf *buf = g_hash_table_lookup ( cache, key );
  86     if (buf) {
  87       queue_size -= gdk_pixbuf_get_rowstride(buf) * gdk_pixbuf_get_height(buf);
  88       queue_size -= 100;
  89       queue_count --;
  90       g_hash_table_remove ( cache, key );
  91     }
  92 }
  93
  94 /* returns key from head, adds on newtailkey to tail. */
  95 static gchar *list_shift_add_entry ( gchar *newtailkey )
  96 {
  97   gchar *oldheadkey = queue_tail->next->key;
  98   queue_tail->next->key = newtailkey;
  99   queue_tail = queue_tail->next;
 100   return oldheadkey;
 101 }
 102
 103 static gchar *list_shift ()
 104 {
 105   gchar *oldheadkey = queue_tail->next->key;
 106   List *oldhead = queue_tail->next;
 107   queue_tail->next = queue_tail->next->next;
 108   g_free ( oldhead );
 109   return oldheadkey;
 110 }
 111
 112 /* adds key to tail */
 113 static void list_add_entry ( gchar *key )
 114 {
 115   List *newlist = g_malloc ( sizeof ( List ) );
 116   newlist->key = key;
 117   if ( queue_tail ) {
 118     newlist->next = queue_tail->next;
 119     queue_tail->next = newlist;
 120     queue_tail = newlist;
 121   } else {
 122     newlist->next = newlist;
 123     queue_tail = newlist;
 124   }
 125 }
 126
 127 void a_mapcache_add ( GdkPixbuf *pixbuf, gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor )
 128 {
 129   gchar *key = g_strdup_printf ( HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor );
 130   static int tmp = 0;
 131
 132   g_mutex_lock(mc_mutex);
 133   cache_add(key, pixbuf);
 134
 135   // TODO: that should be done on preference change only...
 136   max_queue_size = a_preferences_get(VIKING_PREFERENCES_NAMESPACE "mapcache_size")->u * 1024 * 1024;
 137
 138   if ( queue_size > max_queue_size ) {
 139     gchar *oldkey = list_shift_add_entry ( key );
 140     cache_remove(oldkey);
 141
 142     while ( queue_size > max_queue_size &&
 143         (queue_tail->next != queue_tail) ) { /* make sure there's more than one thing to delete */
 144       oldkey = list_shift ();
 145       cache_remove(oldkey);
 146     }
 147
 148     /* chop off 'start' etc */
 149   } else {
 150     list_add_entry ( key );
 151     /* business as usual */
 152   }
 153   g_mutex_unlock(mc_mutex);
 154
 155   if ( (++tmp == 100 ))  { g_print("DEBUG: queue count=%d size=%u\n", queue_count, queue_size ); tmp=0; }
 156 }
 157
 158 GdkPixbuf *a_mapcache_get ( gint x, gint y, gint z, guint8 type, guint zoom, guint8 alpha, gdouble xshrinkfactor, gdouble yshrinkfactor )
 159 {
 160   static char key[48];
 161   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING, x, y, z, type, zoom, alpha, xshrinkfactor, yshrinkfactor );
 162   return g_hash_table_lookup ( cache, key );
 163 }
 164
 165 void a_mapcache_remove_all_shrinkfactors ( gint x, gint y, gint z, guint8 type, guint zoom )
 166 {
 167   char key[40];
 168   List *loop = queue_tail;
 169   List *tmp;
 170   gint len;
 171
 172   if ( queue_tail == NULL )
 173     return;
 174
 175   g_snprintf ( key, sizeof(key), HASHKEY_FORMAT_STRING_NOSHRINK_NOR_ALPHA, x, y, z, type, zoom );
 176   len = strlen(key);
 177
 178   g_mutex_lock(mc_mutex);
 179   /* TODO: check logic here */
 180   do {
 181     tmp = loop->next;
 182     if ( strncmp(tmp->key, key, len) == 0 )
 183     {
 184       cache_remove(tmp->key);
 185       if ( tmp == loop ) /* we deleted the last thing in the queue! */
 186         loop = queue_tail = NULL;
 187       else {
 188         loop->next = tmp->next;
 189         if ( tmp == queue_tail )
 190           queue_tail = tmp->next;
 191       }
 192       g_free ( tmp );
 193       tmp = NULL;
 194     }
 195     else
 196       loop = tmp;
 197
 198   } while ( loop && (loop != queue_tail || tmp == NULL) );
 199
 200   /* loop thru list, looking for the one, compare first whatever chars */
 201   cache_remove(key);
 202   g_mutex_unlock(mc_mutex);
 203 }
 204
 205 void a_mapcache_flush ()
 206 {
 207   List *loop = queue_tail;
 208   List *tmp;
 209
 210   if ( queue_tail == NULL )
 211     return;
 212
 213   g_mutex_lock(mc_mutex);
 214   do {
 215     tmp = loop->next;
 216     cache_remove(tmp->key);
 217     if ( tmp == queue_tail ) /* we deleted the last thing in the queue */
 218       loop = queue_tail = NULL;
 219     else
 220       loop->next = tmp->next;
 221     g_free ( tmp );
 222     tmp = NULL;
 223   } while ( loop );
 224
 225   g_mutex_unlock(mc_mutex);
 226 }
 227
 228 void a_mapcache_uninit ()
 229 {
 230   g_hash_table_destroy ( cache );
 231   /* free list */
 232   cache = NULL;
 233 }
 234
 235