base/applications/mstsc/cache.c

   1 /* -*- c-basic-offset: 8 -*-
   2    rdesktop: A Remote Desktop Protocol client.
   3    Cache routines
   4    Copyright (C) Matthew Chapman 1999-2005
   5    Copyright (C) Jeroen Meijer 2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License along
  18    with this program; if not, write to the Free Software Foundation, Inc.,
  19    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 */
  21
  22 #include <precomp.h>
  23
  24 /* BITMAP CACHE */
  25 extern int g_pstcache_fd[];
  26
  27 #define NUM_ELEMENTS(array) (sizeof(array) / sizeof(array[0]))
  28 //#define IS_PERSISTENT(id) (g_pstcache_fd[id] > 0)
  29 #define TO_TOP -1
  30 #define NOT_SET -1
  31 #define IS_SET(idx) (idx >= 0)
  32
  33 /*
  34  * TODO: Test for optimal value of BUMP_COUNT. TO_TOP gives lowest cpu utilisation but using
  35  * a positive value will hopefully result in less frequently used bitmaps having a greater chance
  36  * of being evicted from the cache, and therby reducing the need to load bitmaps from disk.
  37  * (Jeroen)
  38  */
  39 #define BUMP_COUNT 40
  40
  41 struct bmpcache_entry
  42 {
  43         RD_HBITMAP bitmap;
  44         sint16 previous;
  45         sint16 next;
  46 };
  47
  48 static struct bmpcache_entry g_bmpcache[3][0xa00];
  49 static RD_HBITMAP g_volatile_bc[3];
  50
  51 static int g_bmpcache_lru[3] = { NOT_SET, NOT_SET, NOT_SET };
  52 static int g_bmpcache_mru[3] = { NOT_SET, NOT_SET, NOT_SET };
  53 static int g_bmpcache_count[3];
  54
  55 /* Setup the bitmap cache lru/mru linked list */
  56 void
  57 cache_rebuild_bmpcache_linked_list(uint8 id, sint16 * idx, int count)
  58 {
  59         int n = count, c = 0;
  60         sint16 n_idx;
  61
  62         /* find top, skip evicted bitmaps */
  63         while (--n >= 0 && g_bmpcache[id][idx[n]].bitmap == NULL);
  64         if (n < 0)
  65         {
  66                 g_bmpcache_mru[id] = g_bmpcache_lru[id] = NOT_SET;
  67                 return;
  68         }
  69
  70         g_bmpcache_mru[id] = idx[n];
  71         g_bmpcache[id][idx[n]].next = NOT_SET;
  72         n_idx = idx[n];
  73         c++;
  74
  75         /* link list */
  76         while (n >= 0)
  77         {
  78                 /* skip evicted bitmaps */
  79                 while (--n >= 0 && g_bmpcache[id][idx[n]].bitmap == NULL);
  80
  81                 if (n < 0)
  82                         break;
  83
  84                 g_bmpcache[id][n_idx].previous = idx[n];
  85                 g_bmpcache[id][idx[n]].next = n_idx;
  86                 n_idx = idx[n];
  87                 c++;
  88         }
  89
  90         g_bmpcache[id][n_idx].previous = NOT_SET;
  91         g_bmpcache_lru[id] = n_idx;
  92
  93         if (c != g_bmpcache_count[id])
  94         {
  95                 error("Oops. %d in bitmap cache linked list, %d in ui cache...\n", c,
  96                       g_bmpcache_count[id]);
  97                 exit(1);
  98         }
  99 }
 100
 101 /* Move a bitmap to a new position in the linked list. */
 102 void
 103 cache_bump_bitmap(uint8 id, uint16 idx, int bump)
 104 {
 105         int p_idx, n_idx, n;
 106
 107         if (!IS_PERSISTENT(id))
 108                 return;
 109
 110         if (g_bmpcache_mru[id] == idx)
 111                 return;
 112
 113         DEBUG_RDP5(("bump bitmap: id=%d, idx=%d, bump=%d\n", id, idx, bump));
 114
 115         n_idx = g_bmpcache[id][idx].next;
 116         p_idx = g_bmpcache[id][idx].previous;
 117
 118         if (IS_SET(n_idx))
 119         {
 120                 /* remove */
 121                 --g_bmpcache_count[id];
 122                 if (IS_SET(p_idx))
 123                         g_bmpcache[id][p_idx].next = n_idx;
 124                 else
 125                         g_bmpcache_lru[id] = n_idx;
 126                 if (IS_SET(n_idx))
 127                         g_bmpcache[id][n_idx].previous = p_idx;
 128                 else
 129                         g_bmpcache_mru[id] = p_idx;
 130         }
 131         else
 132         {
 133                 p_idx = NOT_SET;
 134                 n_idx = g_bmpcache_lru[id];
 135         }
 136
 137         if (bump >= 0)
 138         {
 139                 for (n = 0; n < bump && IS_SET(n_idx); n++)
 140                 {
 141                         p_idx = n_idx;
 142                         n_idx = g_bmpcache[id][p_idx].next;
 143                 }
 144         }
 145         else
 146         {
 147                 p_idx = g_bmpcache_mru[id];
 148                 n_idx = NOT_SET;
 149         }
 150
 151         /* insert */
 152         ++g_bmpcache_count[id];
 153         g_bmpcache[id][idx].previous = p_idx;
 154         g_bmpcache[id][idx].next = n_idx;
 155
 156         if (p_idx >= 0)
 157                 g_bmpcache[id][p_idx].next = idx;
 158         else
 159                 g_bmpcache_lru[id] = idx;
 160
 161         if (n_idx >= 0)
 162                 g_bmpcache[id][n_idx].previous = idx;
 163         else
 164                 g_bmpcache_mru[id] = idx;
 165 }
 166
 167 /* Evict the least-recently used bitmap from the cache */
 168 void
 169 cache_evict_bitmap(uint8 id)
 170 {
 171         uint16 idx;
 172         int n_idx;
 173
 174         if (!IS_PERSISTENT(id))
 175                 return;
 176
 177         idx = g_bmpcache_lru[id];
 178         n_idx = g_bmpcache[id][idx].next;
 179         DEBUG_RDP5(("evict bitmap: id=%d idx=%d n_idx=%d bmp=0x%x\n", id, idx, n_idx,
 180                     g_bmpcache[id][idx].bitmap));
 181
 182         ui_destroy_bitmap(g_bmpcache[id][idx].bitmap);
 183         --g_bmpcache_count[id];
 184         g_bmpcache[id][idx].bitmap = 0;
 185
 186         g_bmpcache_lru[id] = n_idx;
 187         g_bmpcache[id][n_idx].previous = NOT_SET;
 188
 189         pstcache_touch_bitmap(id, idx, 0);
 190 }
 191
 192 /* Retrieve a bitmap from the cache */
 193 RD_HBITMAP
 194 cache_get_bitmap(uint8 id, uint16 idx)
 195 {
 196         if ((id < NUM_ELEMENTS(g_bmpcache)) && (idx < NUM_ELEMENTS(g_bmpcache[0])))
 197         {
 198                 if (g_bmpcache[id][idx].bitmap || pstcache_load_bitmap(id, idx))
 199                 {
 200                         if (IS_PERSISTENT(id))
 201                                 cache_bump_bitmap(id, idx, BUMP_COUNT);
 202
 203                         return g_bmpcache[id][idx].bitmap;
 204                 }
 205         }
 206         else if ((id < NUM_ELEMENTS(g_volatile_bc)) && (idx == 0x7fff))
 207         {
 208                 return g_volatile_bc[id];
 209         }
 210
 211         error("get bitmap %d:%d\n", id, idx);
 212         return NULL;
 213 }
 214
 215 /* Store a bitmap in the cache */
 216 void
 217 cache_put_bitmap(uint8 id, uint16 idx, RD_HBITMAP bitmap)
 218 {
 219         RD_HBITMAP old;
 220
 221         if ((id < NUM_ELEMENTS(g_bmpcache)) && (idx < NUM_ELEMENTS(g_bmpcache[0])))
 222         {
 223                 old = g_bmpcache[id][idx].bitmap;
 224                 if (old != NULL)
 225                         ui_destroy_bitmap(old);
 226                 g_bmpcache[id][idx].bitmap = bitmap;
 227
 228                 if (IS_PERSISTENT(id))
 229                 {
 230                         if (old == NULL)
 231                                 g_bmpcache[id][idx].previous = g_bmpcache[id][idx].next = NOT_SET;
 232
 233                         cache_bump_bitmap(id, idx, TO_TOP);
 234                         if (g_bmpcache_count[id] > BMPCACHE2_C2_CELLS)
 235                                 cache_evict_bitmap(id);
 236                 }
 237         }
 238         else if ((id < NUM_ELEMENTS(g_volatile_bc)) && (idx == 0x7fff))
 239         {
 240                 old = g_volatile_bc[id];
 241                 if (old != NULL)
 242                         ui_destroy_bitmap(old);
 243                 g_volatile_bc[id] = bitmap;
 244         }
 245         else
 246         {
 247                 error("put bitmap %d:%d\n", id, idx);
 248         }
 249 }
 250
 251 /* Updates the persistent bitmap cache MRU information on exit */
 252 void
 253 cache_save_state(void)
 254 {
 255         uint32 id = 0, t = 0;
 256         int idx;
 257
 258         for (id = 0; id < NUM_ELEMENTS(g_bmpcache); id++)
 259                 if (IS_PERSISTENT(id))
 260                 {
 261                         DEBUG_RDP5(("Saving cache state for bitmap cache %d...", id));
 262                         idx = g_bmpcache_lru[id];
 263                         while (idx >= 0)
 264                         {
 265                                 pstcache_touch_bitmap((uint8) id, (uint16) idx, ++t);
 266                                 idx = g_bmpcache[id][idx].next;
 267                         }
 268                         DEBUG_RDP5((" %d stamps written.\n", t));
 269                 }
 270 }
 271
 272
 273 /* FONT CACHE */
 274 static FONTGLYPH g_fontcache[12][256];
 275
 276 /* Retrieve a glyph from the font cache */
 277 FONTGLYPH *
 278 cache_get_font(uint8 font, uint16 character)
 279 {
 280         FONTGLYPH *glyph;
 281
 282         if ((font < NUM_ELEMENTS(g_fontcache)) && (character < NUM_ELEMENTS(g_fontcache[0])))
 283         {
 284                 glyph = &g_fontcache[font][character];
 285                 if (glyph->pixmap != NULL)
 286                         return glyph;
 287         }
 288
 289         error("get font %d:%d\n", font, character);
 290         return NULL;
 291 }
 292
 293 /* Store a glyph in the font cache */
 294 void
 295 cache_put_font(uint8 font, uint16 character, uint16 offset,
 296                uint16 baseline, uint16 width, uint16 height, RD_HGLYPH pixmap)
 297 {
 298         FONTGLYPH *glyph;
 299
 300         if ((font < NUM_ELEMENTS(g_fontcache)) && (character < NUM_ELEMENTS(g_fontcache[0])))
 301         {
 302                 glyph = &g_fontcache[font][character];
 303                 if (glyph->pixmap != NULL)
 304                         ui_destroy_glyph(glyph->pixmap);
 305
 306                 glyph->offset = offset;
 307                 glyph->baseline = baseline;
 308                 glyph->width = width;
 309                 glyph->height = height;
 310                 glyph->pixmap = pixmap;
 311         }
 312         else
 313         {
 314                 error("put font %d:%d\n", font, character);
 315         }
 316 }
 317
 318
 319 /* TEXT CACHE */
 320 static DATABLOB g_textcache[256];
 321
 322 /* Retrieve a text item from the cache */
 323 DATABLOB *
 324 cache_get_text(uint8 cache_id)
 325 {
 326         DATABLOB *text;
 327
 328         text = &g_textcache[cache_id];
 329         return text;
 330 }
 331
 332 /* Store a text item in the cache */
 333 void
 334 cache_put_text(uint8 cache_id, void *data, int length)
 335 {
 336         DATABLOB *text;
 337
 338         text = &g_textcache[cache_id];
 339         if (text->data != NULL)
 340                 xfree(text->data);
 341         text->data = xmalloc(length);
 342         text->size = length;
 343         memcpy(text->data, data, length);
 344 }
 345
 346
 347 /* DESKTOP CACHE */
 348 static uint8 g_deskcache[0x38400 * 4];
 349
 350 /* Retrieve desktop data from the cache */
 351 uint8 *
 352 cache_get_desktop(uint32 offset, int cx, int cy, int bytes_per_pixel)
 353 {
 354         int length = cx * cy * bytes_per_pixel;
 355
 356         if (offset > sizeof(g_deskcache))
 357                 offset = 0;
 358
 359         if ((offset + length) <= sizeof(g_deskcache))
 360         {
 361                 return &g_deskcache[offset];
 362         }
 363
 364         error("get desktop %d:%d\n", offset, length);
 365         return NULL;
 366 }
 367
 368 /* Store desktop data in the cache */
 369 void
 370 cache_put_desktop(uint32 offset, int cx, int cy, int scanline, int bytes_per_pixel, uint8 * data)
 371 {
 372         int length = cx * cy * bytes_per_pixel;
 373
 374         if (offset > sizeof(g_deskcache))
 375                 offset = 0;
 376
 377         if ((offset + length) <= sizeof(g_deskcache))
 378         {
 379                 cx *= bytes_per_pixel;
 380                 while (cy--)
 381                 {
 382                         memcpy(&g_deskcache[offset], data, cx);
 383                         data += scanline;
 384                         offset += cx;
 385                 }
 386         }
 387         else
 388         {
 389                 error("put desktop %d:%d\n", offset, length);
 390         }
 391 }
 392
 393
 394 /* CURSOR CACHE */
 395 static RD_HCURSOR g_cursorcache[0x20];
 396
 397 /* Retrieve cursor from cache */
 398 RD_HCURSOR
 399 cache_get_cursor(uint16 cache_idx)
 400 {
 401         RD_HCURSOR cursor;
 402
 403         if (cache_idx < NUM_ELEMENTS(g_cursorcache))
 404         {
 405                 cursor = g_cursorcache[cache_idx];
 406                 if (cursor != NULL)
 407                         return cursor;
 408         }
 409
 410         error("get cursor %d\n", cache_idx);
 411         return NULL;
 412 }
 413
 414 /* Store cursor in cache */
 415 void
 416 cache_put_cursor(uint16 cache_idx, RD_HCURSOR cursor)
 417 {
 418         RD_HCURSOR old;
 419
 420         if (cache_idx < NUM_ELEMENTS(g_cursorcache))
 421         {
 422                 old = g_cursorcache[cache_idx];
 423                 if (old != NULL)
 424                         ui_destroy_cursor(old);
 425
 426                 g_cursorcache[cache_idx] = cursor;
 427         }
 428         else
 429         {
 430                 error("put cursor %d\n", cache_idx);
 431         }
 432 }