OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

8bpp_optimized.cpp
Go to the documentation of this file.
1 /* $Id: 8bpp_optimized.cpp 26969 2014-10-06 18:45:51Z rubidium $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8 */
9
12 #include "../stdafx.h"
13 #include "../zoom_func.h"
14 #include "../settings_type.h"
15 #include "../core/math_func.hpp"
16 #include "../core/mem_func.hpp"
17 #include "8bpp_optimized.hpp"
18
19 #include "../safeguards.h"
20
22 static FBlitter_8bppOptimized iFBlitter_8bppOptimized;
23
24 void Blitter_8bppOptimized::Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom)
25 {
26 /* Find the offset of this zoom-level */
27 const SpriteData *sprite_src = (const SpriteData *)bp->sprite;
28 uint offset = sprite_src->offset[zoom];
29
30 /* Find where to start reading in the source sprite */
31 const uint8 *src = sprite_src->data + offset;
32 uint8 *dst_line = (uint8 *)bp->dst + bp->top * bp->pitch + bp->left;
33
34 /* Skip over the top lines in the source image */
35 for (int y = 0; y < bp->skip_top; y++) {
36 for (;;) {
37 uint trans = *src++;
38 uint pixels = *src++;
39 if (trans == 0 && pixels == 0) break;
40 src += pixels;
41 }
42 }
43
44 const uint8 *src_next = src;
45
46 for (int y = 0; y < bp->height; y++) {
47 uint8 *dst = dst_line;
48 dst_line += bp->pitch;
49
50 uint skip_left = bp->skip_left;
51 int width = bp->width;
52
53 for (;;) {
54 src = src_next;
55 uint trans = *src++;
56 uint pixels = *src++;
57 src_next = src + pixels;
58 if (trans == 0 && pixels == 0) break;
59 if (width <= 0) continue;
60
61 if (skip_left != 0) {
62 if (skip_left < trans) {
63 trans -= skip_left;
64 skip_left = 0;
65 } else {
66 skip_left -= trans;
67 trans = 0;
68 }
69 if (skip_left < pixels) {
70 src += skip_left;
71 pixels -= skip_left;
72 skip_left = 0;
73 } else {
74 src += pixels;
75 skip_left -= pixels;
76 pixels = 0;
77 }
78 }
79 if (skip_left != 0) continue;
80
81 /* Skip transparent pixels */
82 dst += trans;
83 width -= trans;
84 if (width <= 0 || pixels == 0) continue;
85 pixels = min<uint>(pixels, (uint)width);
86 width -= pixels;
87
88 switch (mode) {
89 case BM_COLOUR_REMAP:
90 case BM_CRASH_REMAP: {
91 const uint8 *remap = bp->remap;
92 do {
93 uint m = remap[*src];
94 if (m != 0) *dst = m;
95 dst++; src++;
96 } while (--pixels != 0);
97 break;
98 }
99
100 case BM_BLACK_REMAP:
101 MemSetT(dst, 0, pixels);
102 dst += pixels;
103 break;
104
105 case BM_TRANSPARENT: {
106 const uint8 *remap = bp->remap;
107 src += pixels;
108 do {
109 *dst = remap[*dst];
110 dst++;
111 } while (--pixels != 0);
112 break;
113 }
114
115 default:
116 MemCpyT(dst, src, pixels);
117 dst += pixels; src += pixels;
118 break;
119 }
120 }
121 }
122 }
123
124 Sprite *Blitter_8bppOptimized::Encode(const SpriteLoader::Sprite *sprite, AllocatorProc *allocator)
125 {
126 /* Make memory for all zoom-levels */
127 uint memory = sizeof(SpriteData);
128
129 ZoomLevel zoom_min;
130 ZoomLevel zoom_max;
131
132 if (sprite->type == ST_FONT) {
133 zoom_min = ZOOM_LVL_NORMAL;
134 zoom_max = ZOOM_LVL_NORMAL;
135 } else {
136 zoom_min = _settings_client.gui.zoom_min;
137 zoom_max = _settings_client.gui.zoom_max;
138 if (zoom_max == zoom_min) zoom_max = ZOOM_LVL_MAX;
139 }
140
141 for (ZoomLevel i = zoom_min; i <= zoom_max; i++) {
142 memory += sprite[i].width * sprite[i].height;
143 }
144
145 /* We have no idea how much memory we really need, so just guess something */
146 memory *= 5;
147
148 /* Don't allocate memory each time, but just keep some
149 * memory around as this function is called quite often
150 * and the memory usage is quite low. */
151 static ReusableBuffer<byte> temp_buffer;
152 SpriteData *temp_dst = (SpriteData *)temp_buffer.Allocate(memory);
153 memset(temp_dst, 0, sizeof(*temp_dst));
154 byte *dst = temp_dst->data;
155
156 /* Make the sprites per zoom-level */
157 for (ZoomLevel i = zoom_min; i <= zoom_max; i++) {
158 /* Store the index table */
159 uint offset = dst - temp_dst->data;
160 temp_dst->offset[i] = offset;
161
162 /* cache values, because compiler can't cache it */
163 int scaled_height = sprite[i].height;
164 int scaled_width = sprite[i].width;
165
166 for (int y = 0; y < scaled_height; y++) {
167 uint trans = 0;
168 uint pixels = 0;
169 uint last_colour = 0;
170 byte *count_dst = NULL;
171
172 /* Store the scaled image */
173 const SpriteLoader::CommonPixel *src = &sprite[i].data[y * sprite[i].width];
174
175 for (int x = 0; x < scaled_width; x++) {
176 uint colour = src++->m;
177
178 if (last_colour == 0 || colour == 0 || pixels == 255) {
179 if (count_dst != NULL) {
180 /* Write how many non-transparent bytes we get */
181 *count_dst = pixels;
182 pixels = 0;
183 count_dst = NULL;
184 }
185 /* As long as we find transparency bytes, keep counting */
186 if (colour == 0 && trans != 255) {
187 last_colour = 0;
188 trans++;
189 continue;
190 }
191 /* No longer transparency, so write the amount of transparent bytes */
192 *dst = trans;
193 dst++;
194 trans = 0;
195 /* Reserve a byte for the pixel counter */
196 count_dst = dst;
197 dst++;
198 }
199 last_colour = colour;
200 if (colour == 0) {
201 trans++;
202 } else {
203 pixels++;
204 *dst = colour;
205 dst++;
206 }
207 }
208
209 if (count_dst != NULL) *count_dst = pixels;
210
211 /* Write line-ending */
212 *dst = 0; dst++;
213 *dst = 0; dst++;
214 }
215 }
216
217 uint size = dst - (byte *)temp_dst;
218
219 /* Safety check, to make sure we guessed the size correctly */
220 assert(size < memory);
221
222 /* Allocate the exact amount of memory we need */
223 Sprite *dest_sprite = (Sprite *)allocator(sizeof(*dest_sprite) + size);
224
225 dest_sprite->height = sprite->height;
226 dest_sprite->width = sprite->width;
227 dest_sprite->x_offs = sprite->x_offs;
228 dest_sprite->y_offs = sprite->y_offs;
229 memcpy(dest_sprite->data, temp_dst, size);
230
231 return dest_sprite;
232 }