1

/* $Id$ */

     2

     3

/** @file 8bpp_optimized.cpp Implementation of the optimized 8 bpp blitter. */

     4

     5

#include "../stdafx.h"

     6

#include "../zoom_func.h"

     7

#include "../debug.h"

     8

#include "../core/alloc_func.hpp"

     9

#include "../core/math_func.hpp"

    10

#include "8bpp_optimized.hpp"

    11

    12

static FBlitter_8bppOptimized iFBlitter_8bppOptimized;

    13

    14

void Blitter_8bppOptimized::Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom)

    15

{

    16

	/* Find the offset of this zoom-level */

    17

	const SpriteData *sprite_src = (const SpriteData *)bp->sprite;

    18

	uint offset = sprite_src->offset[zoom];

    19

    20

	/* Find where to start reading in the source sprite */

    21

	const uint8 *src = sprite_src->data + offset;

    22

	uint8 *dst_line = (uint8 *)bp->dst + bp->top * bp->pitch + bp->left;

    23

    24

	/* Skip over the top lines in the source image */

    25

	for (int y = 0; y < bp->skip_top; y++) {

    26

		for (;;) {

    27

			uint trans = *src++;

    28

			uint pixels = *src++;

    29

			if (trans == 0 && pixels == 0) break;

    30

			src += pixels;

    31

		}

    32

	}

    33

    34

	const uint8 *src_next = src;

    35

    36

	for (int y = 0; y < bp->height; y++) {

    37

		uint8 *dst = dst_line;

    38

		dst_line += bp->pitch;

    39

    40

		uint skip_left = bp->skip_left;

    41

		int width = bp->width;

    42

    43

		for (;;) {

    44

			src = src_next;

    45

			uint trans = *src++;

    46

			uint pixels = *src++;

    47

			src_next = src + pixels;

    48

			if (trans == 0 && pixels == 0) break;

    49

			if (width <= 0) continue;

    50

    51

			if (skip_left != 0) {

    52

				if (skip_left < trans) {

    53

					trans -= skip_left;

    54

					skip_left = 0;

    55

				} else {

    56

					skip_left -= trans;

    57

					trans = 0;

    58

				}

    59

				if (skip_left < pixels) {

    60

					src += skip_left;

    61

					pixels -= skip_left;

    62

					skip_left = 0;

    63

				} else {

    64

					src += pixels;

    65

					skip_left -= pixels;

    66

					pixels = 0;

    67

				}

    68

			}

    69

			if (skip_left != 0) continue;

    70

    71

			/* Skip transparent pixels */

    72

			dst += trans;

    73

			width -= trans;

    74

			if (width <= 0 || pixels == 0) continue;

    75

			pixels = min<uint>(pixels, (uint)width);

    76

			width -= pixels;

    77

    78

			switch (mode) {

    79

				case BM_COLOUR_REMAP: {

    80

					const uint8 *remap = bp->remap;

    81

					do {

    82

						uint m = remap[*src];

    83

						if (m != 0) *dst = m;

    84

						dst++; src++;

    85

					} while (--pixels != 0);

    86

				} break;

    87

    88

				case BM_TRANSPARENT: {

    89

					const uint8 *remap = bp->remap;

    90

					src += pixels;

    91

					do {

    92

						*dst = remap[*dst];

    93

						dst++;

    94

					} while (--pixels != 0);

    95

				} break;

    96

    97

				default:

    98

					memcpy(dst, src, pixels);

    99

					dst += pixels; src += pixels;

   100

					break;

   101

			}

   102

		}

   103

	}

   104

}

   105

   106

Sprite *Blitter_8bppOptimized::Encode(SpriteLoader::Sprite *sprite, Blitter::AllocatorProc *allocator)

   107

{

   108

	/* Make memory for all zoom-levels */

   109

	uint memory = sizeof(SpriteData);

   110

   111

	for (ZoomLevel i = ZOOM_LVL_BEGIN; i < ZOOM_LVL_END; i++) {

   112

		memory += UnScaleByZoom(sprite->height, i) * UnScaleByZoom(sprite->width, i);

   113

	}

   114

   115

	/* We have no idea how much memory we really need, so just guess something */

   116

	memory *= 5;

   117

	SpriteData *temp_dst = (SpriteData *)MallocT<byte>(memory);

   118

	byte *dst = temp_dst->data;

   119

   120

	/* Make the sprites per zoom-level */

   121

	for (ZoomLevel i = ZOOM_LVL_BEGIN; i < ZOOM_LVL_END; i++) {

   122

		/* Store the index table */

   123

		uint offset = dst - temp_dst->data;

   124

		temp_dst->offset[i] = offset;

   125

   126

		/* cache values, because compiler can't cache it */

   127

		int scaled_height = UnScaleByZoom(sprite->height, i);

   128

		int scaled_width  = UnScaleByZoom(sprite->width,  i);

   129

		int scaled_1      =   ScaleByZoom(1,              i);

   130

   131

		for (int y = 0; y < scaled_height; y++) {

   132

			uint trans = 0;

   133

			uint pixels = 0;

   134

			uint last_colour = 0;

   135

			byte *count_dst = NULL;

   136

   137

			/* Store the scaled image */

   138

			const SpriteLoader::CommonPixel *src = &sprite->data[ScaleByZoom(y, i) * sprite->width];

   139

			const SpriteLoader::CommonPixel *src_end = &src[sprite->width];

   140

   141

			for (int x = 0; x < scaled_width; x++) {

   142

				uint colour = 0;

   143

   144

				/* Get the color keeping in mind the zoom-level */

   145

				for (int j = 0; j < scaled_1; j++) {

   146

					if (src->m != 0) colour = src->m;

   147

					/* Because of the scaling it might happen we read outside the buffer. Avoid that. */

   148

					if (++src == src_end) break;

   149

				}

   150

   151

				if (last_colour == 0 || colour == 0 || pixels == 255) {

   152

					if (count_dst != NULL) {

   153

						/* Write how many non-transparent bytes we get */

   154

						*count_dst = pixels;

   155

						pixels = 0;

   156

						count_dst = NULL;

   157

					}

   158

					/* As long as we find transparency bytes, keep counting */

   159

					if (colour == 0) {

   160

						last_colour = 0;

   161

						trans++;

   162

						continue;

   163

					}

   164

					/* No longer transparency, so write the amount of transparent bytes */

   165

					*dst = trans;

   166

					dst++;

   167

					trans = 0;

   168

					/* Reserve a byte for the pixel counter */

   169

					count_dst = dst;

   170

					dst++;

   171

				}

   172

				last_colour = colour;

   173

				pixels++;

   174

				*dst = colour;

   175

				dst++;

   176

			}

   177

   178

			if (count_dst != NULL) *count_dst = pixels;

   179

   180

			/* Write line-ending */

   181

			*dst = 0; dst++;

   182

			*dst = 0; dst++;

   183

		}

   184

	}

   185

   186

	uint size = dst - (byte *)temp_dst;

   187

   188

	/* Safety check, to make sure we guessed the size correctly */

   189

	assert(size < memory);

   190

   191

	/* Allocate the exact amount of memory we need */

   192

	Sprite *dest_sprite = (Sprite *)allocator(sizeof(*dest_sprite) + size);

   193

   194

	dest_sprite->height = sprite->height;

   195

	dest_sprite->width  = sprite->width;

   196

	dest_sprite->x_offs = sprite->x_offs;

   197

	dest_sprite->y_offs = sprite->y_offs;

   198

	memcpy(dest_sprite->data, temp_dst, size);

   199

	free(temp_dst);

   200

   201

	return dest_sprite;

   202

}