diff options
Diffstat (limited to 'apps/gui/skin_engine/skin_buffer.c')
-rw-r--r-- | apps/gui/skin_engine/skin_buffer.c | 170 |
1 files changed, 0 insertions, 170 deletions
diff --git a/apps/gui/skin_engine/skin_buffer.c b/apps/gui/skin_engine/skin_buffer.c deleted file mode 100644 index d503b83e42..0000000000 --- a/apps/gui/skin_engine/skin_buffer.c +++ /dev/null | |||
@@ -1,170 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2002 by Linus Nielsen Feltzing | ||
11 | * Copyright (C) 2009 Jonathan Gordon | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU General Public License | ||
15 | * as published by the Free Software Foundation; either version 2 | ||
16 | * of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
19 | * KIND, either express or implied. | ||
20 | * | ||
21 | ****************************************************************************/ | ||
22 | |||
23 | #include <stdio.h> | ||
24 | #include <string.h> | ||
25 | #include <stdlib.h> | ||
26 | #include "config.h" | ||
27 | #include "buffer.h" | ||
28 | #include "settings.h" | ||
29 | #include "screen_access.h" | ||
30 | #include "skin_engine.h" | ||
31 | #include "wps_internals.h" | ||
32 | #include "skin_tokens.h" | ||
33 | #include "skin_buffer.h" | ||
34 | #include "skin_fonts.h" | ||
35 | |||
36 | /* skin buffer management. | ||
37 | * This module is used to allocate space in a single global skin buffer for | ||
38 | * tokens for both/all screens. | ||
39 | * | ||
40 | * This is mostly just copy/paste from firmware/buffer.c | ||
41 | * | ||
42 | * | ||
43 | * MAIN_ and REMOTE_BUFFER are just for reasonable size calibration, | ||
44 | * both screens can use the whole buffer as they need; it's not split | ||
45 | * between screens | ||
46 | * | ||
47 | * Buffer can be allocated from either "end" of the global buffer. | ||
48 | * items with unknown sizes get allocated from the start (0->) (data) | ||
49 | * items with known sizes get allocated from the end (<-buf_size) (tokens) | ||
50 | * After loading 2 skins the buffer will look like this: | ||
51 | * |tokens skin1|images skin1|tokens s2|images s2|---SPACE---|data skin2|data skin1| | ||
52 | * Make sure to never start allocating from the beginning before letting us know | ||
53 | * how much was used. and RESPECT THE buf_free RETURN VALUES! | ||
54 | * | ||
55 | */ | ||
56 | |||
57 | |||
58 | #ifdef HAVE_LCD_BITMAP | ||
59 | #define MAIN_BUFFER ((2*LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \ | ||
60 | + (SKINNABLE_SCREENS_COUNT * LCD_BACKDROP_BYTES)) | ||
61 | |||
62 | #if (NB_SCREENS > 1) | ||
63 | #define REMOTE_BUFFER (2*(LCD_REMOTE_HEIGHT*LCD_REMOTE_WIDTH*LCD_REMOTE_DEPTH/8) \ | ||
64 | + (SKINNABLE_SCREENS_COUNT * REMOTE_LCD_BACKDROP_BYTES)) | ||
65 | #else | ||
66 | #define REMOTE_BUFFER 0 | ||
67 | #endif | ||
68 | |||
69 | |||
70 | #define SKIN_BUFFER_SIZE (MAIN_BUFFER + REMOTE_BUFFER + SKIN_FONT_SIZE) + \ | ||
71 | (WPS_MAX_TOKENS * sizeof(struct wps_token)) | ||
72 | #endif | ||
73 | |||
74 | #ifdef HAVE_LCD_CHARCELLS | ||
75 | #define SKIN_BUFFER_SIZE (LCD_HEIGHT * LCD_WIDTH) * 64 + \ | ||
76 | (WPS_MAX_TOKENS * sizeof(struct wps_token)) | ||
77 | #endif | ||
78 | |||
79 | static unsigned char buffer[SKIN_BUFFER_SIZE]; | ||
80 | static unsigned char *buffer_front = NULL; /* start of the free space, | ||
81 | increases with allocation*/ | ||
82 | static unsigned char *buffer_back = NULL; /* end of the free space | ||
83 | decreases with allocation */ | ||
84 | static size_t buf_size = SKIN_BUFFER_SIZE; | ||
85 | |||
86 | void skin_buffer_init(void) | ||
87 | { | ||
88 | #if 0 /* this will go in again later probably */ | ||
89 | if (buffer == NULL) | ||
90 | { | ||
91 | buf_size = SKIN_BUFFER_SIZE;/* global_settings.skin_buf_size */ | ||
92 | |||
93 | buffer = buffer_alloc(buf_size); | ||
94 | buffer_front = buffer; | ||
95 | buffer_back = bufer + buf_size; | ||
96 | } | ||
97 | else | ||
98 | #endif | ||
99 | { | ||
100 | /* reset the buffer.... */ | ||
101 | buffer_front = buffer; | ||
102 | buffer_back = buffer + buf_size; | ||
103 | } | ||
104 | } | ||
105 | |||
106 | /* get the number of bytes currently being used */ | ||
107 | size_t skin_buffer_usage(void) | ||
108 | { | ||
109 | return buf_size - (buffer_back-buffer_front); | ||
110 | } | ||
111 | |||
112 | size_t skin_buffer_freespace(void) | ||
113 | { | ||
114 | return buffer_back-buffer_front; | ||
115 | } | ||
116 | |||
117 | /* Allocate size bytes from the buffer | ||
118 | * allocates from the back end (data end) | ||
119 | */ | ||
120 | void* skin_buffer_alloc(size_t size) | ||
121 | { | ||
122 | if (skin_buffer_freespace() <= size) | ||
123 | { | ||
124 | return NULL; | ||
125 | } | ||
126 | buffer_back -= size; | ||
127 | /* 32-bit aligned */ | ||
128 | buffer_back = (void *)(((unsigned long)buffer_back) & ~3); | ||
129 | |||
130 | memset(buffer_back, 0, size); | ||
131 | return buffer_back; | ||
132 | } | ||
133 | |||
134 | /* Get a pointer to the skin buffer and the count of how much is free | ||
135 | * used to do your own buffer management. | ||
136 | * Any memory used will be overwritten next time wps_buffer_alloc() | ||
137 | * is called unless skin_buffer_increment() is called first | ||
138 | * | ||
139 | * This is from the start of the buffer, it is YOUR responsility to make | ||
140 | * sure you dont ever use more then *freespace, and bear in mind this will only | ||
141 | * be valid untill skin_buffer_alloc() is next called... | ||
142 | * so call skin_buffer_increment() and skin_buffer_freespace() regularly | ||
143 | */ | ||
144 | void* skin_buffer_grab(size_t *freespace) | ||
145 | { | ||
146 | *freespace = buf_size - skin_buffer_usage(); | ||
147 | return buffer_front; | ||
148 | } | ||
149 | |||
150 | /* Use after skin_buffer_grab() to specify how much buffer was used */ | ||
151 | void skin_buffer_increment(size_t used, bool align) | ||
152 | { | ||
153 | buffer_front += used; | ||
154 | if (align) | ||
155 | { | ||
156 | /* 32-bit aligned */ | ||
157 | buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3); | ||
158 | } | ||
159 | } | ||
160 | |||
161 | /* free previously skin_buffer_increment()'ed space. This just moves the pointer | ||
162 | * back 'used' bytes so make sure you actually want to do this */ | ||
163 | void skin_buffer_free_from_front(size_t used) | ||
164 | { | ||
165 | buffer_front -= used; | ||
166 | /* 32-bit aligned */ | ||
167 | buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3); | ||
168 | } | ||
169 | |||
170 | |||