cache.c@ 10076

Last change on this file since 10076 was 9902, checked in by vboxsync, 16 years ago
Added rdesktop 1.6.0.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 9.1 KB

Line
1	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3	Cache routines
4	Copyright (C) Matthew Chapman 1999-2007
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
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20	*/
21
22	#include "rdesktop.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(id, 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	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/RDP/client/cache.c@ 10076

Download in other formats: