src/blitter/8bpp_optimized.cpp

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