cache.c@ 8973

Last change on this file since 8973 was 7826, checked in by vboxsync, 17 years ago
Export modified rdesktop version including USB support to OSE. It's GPL anyway.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 9.0 KB

Line
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
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	HBITMAP bitmap;
44	sint16 previous;
45	sint16 next;
46	};
47
48	static struct bmpcache_entry g_bmpcache[3][0xa00];
49	static 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	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, HBITMAP bitmap)
218	{
219	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, 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 HCURSOR g_cursorcache[0x20];
396
397	/* Retrieve cursor from cache */
398	HCURSOR
399	cache_get_cursor(uint16 cache_idx)
400	{
401	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, HCURSOR cursor)
417	{
418	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@ 8973

Download in other formats: