1

/* $Id$ */

     2

     3

/** @file spritecache.cpp Caching of sprites. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "debug.h"

     9

#include "spritecache.h"

    10

#include "fileio_func.h"

    11

#include "spriteloader/grf.hpp"

    12

#include "core/alloc_func.hpp"

    13

#include "core/math_func.hpp"

    14

#include "gfx_func.h"

    15

#ifdef WITH_PNG

    16

#include "spriteloader/png.hpp"

    17

#endif /* WITH_PNG */

    18

#include "blitter/factory.hpp"

    19

    20

#include "table/sprites.h"

    21

    22

/* Default of 4MB spritecache */

    23

uint _sprite_cache_size = 4;

    24

    25

    26

struct SpriteCache {

    27

	void *ptr;

    28

	size_t file_pos;

    29

	uint32 id;

    30

	uint16 file_slot;

    31

	int16 lru;

    32

	SpriteType type; ///< In some cases a single sprite is misused by two NewGRFs. Once as real sprite and once as recolour sprite. If the recolour sprite gets into the cache it might be drawn as real sprite which causes enormous trouble.

    33

};

    34

    35

    36

static uint _spritecache_items = 0;

    37

static SpriteCache *_spritecache = NULL;

    38

    39

    40

static inline SpriteCache *GetSpriteCache(uint index)

    41

{

    42

	return &_spritecache[index];

    43

}

    44

    45

    46

static SpriteCache *AllocateSpriteCache(uint index)

    47

{

    48

	if (index >= _spritecache_items) {

    49

		/* Add another 1024 items to the 'pool' */

    50

		uint items = Align(index + 1, 1024);

    51

    52

		DEBUG(sprite, 4, "Increasing sprite cache to %d items (%d bytes)", items, items * sizeof(*_spritecache));

    53

    54

		_spritecache = ReallocT(_spritecache, items);

    55

    56

		/* Reset the new items and update the count */

    57

		memset(_spritecache + _spritecache_items, 0, (items - _spritecache_items) * sizeof(*_spritecache));

    58

		_spritecache_items = items;

    59

	}

    60

    61

	return GetSpriteCache(index);

    62

}

    63

    64

    65

struct MemBlock {

    66

	size_t size;

    67

	byte data[VARARRAY_SIZE];

    68

};

    69

    70

static uint _sprite_lru_counter;

    71

static MemBlock *_spritecache_ptr;

    72

static int _compact_cache_counter;

    73

    74

static void CompactSpriteCache();

    75

    76

/**

    77

 * Skip the given amount of sprite graphics data.

    78

 * @param type the type of sprite (compressed etc)

    79

 * @param num the amount of sprites to skip

    80

 */

    81

void SkipSpriteData(byte type, uint16 num)

    82

{

    83

	if (type & 2) {

    84

		FioSkipBytes(num);

    85

	} else {

    86

		while (num > 0) {

    87

			int8 i = FioReadByte();

    88

			if (i >= 0) {

    89

				int size = (i == 0) ? 0x80 : i;

    90

				num -= size;

    91

				FioSkipBytes(size);

    92

			} else {

    93

				i = -(i >> 3);

    94

				num -= i;

    95

				FioReadByte();

    96

			}

    97

		}

    98

	}

    99

}

   100

   101

/**

   102

 * Read the sprite header data and then skip the real payload.

   103

 * @return true if the sprite is a pseudo sprite.

   104

 */

   105

static bool ReadSpriteHeaderSkipData()

   106

{

   107

	uint16 num = FioReadWord();

   108

	byte type;

   109

   110

	if (num == 0) return false;

   111

   112

	type = FioReadByte();

   113

	if (type == 0xFF) {

   114

		FioSkipBytes(num);

   115

		/* Some NewGRF files have "empty" pseudo-sprites which are 1

   116

		 * byte long. Catch these so the sprites won't be displayed. */

   117

		return num != 1;

   118

	}

   119

   120

	FioSkipBytes(7);

   121

	SkipSpriteData(type, num - 8);

   122

   123

	return true;

   124

}

   125

   126

/* Check if the given Sprite ID exists */

   127

bool SpriteExists(SpriteID id)

   128

{

   129

	/* Special case for Sprite ID zero -- its position is also 0... */

   130

	if (id == 0) return true;

   131

	if (id >= _spritecache_items) return false;

   132

	return !(GetSpriteCache(id)->file_pos == 0 && GetSpriteCache(id)->file_slot == 0);

   133

}

   134

   135

void* AllocSprite(size_t);

   136

   137

static void* ReadSprite(SpriteCache *sc, SpriteID id, SpriteType sprite_type)

   138

{

   139

	uint8 file_slot = sc->file_slot;

   140

	size_t file_pos = sc->file_pos;

   141

   142

	DEBUG(sprite, 9, "Load sprite %d", id);

   143

   144

	if (!SpriteExists(id)) {

   145

		DEBUG(sprite, 1, "Tried to load non-existing sprite #%d. Probable cause: Wrong/missing NewGRFs", id);

   146

   147

		/* SPR_IMG_QUERY is a BIG FAT RED ? */

   148

		id = SPR_IMG_QUERY;

   149

		file_slot = GetSpriteCache(SPR_IMG_QUERY)->file_slot;

   150

		file_pos  = GetSpriteCache(SPR_IMG_QUERY)->file_pos;

   151

	}

   152

   153

	if (sprite_type == ST_NORMAL && BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth() == 32) {

   154

#ifdef WITH_PNG

   155

		/* Try loading 32bpp graphics in case we are 32bpp output */

   156

		SpriteLoaderPNG sprite_loader;

   157

		SpriteLoader::Sprite sprite;

   158

   159

		if (sprite_loader.LoadSprite(&sprite, file_slot, sc->id, sprite_type)) {

   160

			sc->ptr = BlitterFactoryBase::GetCurrentBlitter()->Encode(&sprite, &AllocSprite);

   161

			free(sprite.data);

   162

   163

			sc->type = sprite_type;

   164

   165

			return sc->ptr;

   166

		}

   167

		/* If the PNG couldn't be loaded, fall back to 8bpp grfs */

   168

#else

   169

		static bool show_once = true;

   170

		if (show_once) {

   171

			DEBUG(misc, 0, "You are running a 32bpp blitter, but this build is without libpng support; falling back to 8bpp graphics");

   172

			show_once = false;

   173

		}

   174

#endif /* WITH_PNG */

   175

	}

   176

   177

	FioSeekToFile(file_slot, file_pos);

   178

   179

	/* Read the size and type */

   180

	int num  = FioReadWord();

   181

	byte type = FioReadByte();

   182

	/* Type 0xFF indicates either a colormap or some other non-sprite info */

   183

	if (type == 0xFF) {

   184

		if (sprite_type != ST_RECOLOUR) {

   185

			static byte warning_level = 0;

   186

			DEBUG(sprite, warning_level, "Tried to load recolour sprite #%d as a real sprite. Probable cause: NewGRF interference", id);

   187

			warning_level = 6;

   188

			if (id == SPR_IMG_QUERY) usererror("Uhm, would you be so kind not to load a NewGRF that makes the 'query' sprite a recolour-sprite?");

   189

			return (void*)GetRawSprite(SPR_IMG_QUERY, ST_NORMAL);

   190

		}

   191

   192

		/* "Normal" recolour sprites are ALWAYS 257 bytes. Then there is a small

   193

		 * number of recolour sprites that are 17 bytes that only exist in DOS

   194

		 * GRFs which are the same as 257 byte recolour sprites, but with the last

   195

		 * 240 bytes zeroed.  */

   196

		static const int RECOLOUR_SPRITE_SIZE = 257;

   197

		byte *dest = (byte *)AllocSprite(max(RECOLOUR_SPRITE_SIZE, num));

   198

   199

		sc->ptr = dest;

   200

		sc->type = sprite_type;

   201

   202

		if (_palette_remap_grf[sc->file_slot]) {

   203

			byte *dest_tmp = AllocaM(byte, max(RECOLOUR_SPRITE_SIZE, num));

   204

   205

			/* Only a few recolour sprites are less than 257 bytes */

   206

			if (num < RECOLOUR_SPRITE_SIZE) memset(dest_tmp, 0, RECOLOUR_SPRITE_SIZE);

   207

			FioReadBlock(dest_tmp, num);

   208

   209

			/* The data of index 0 is never used; "literal 00" according to the (New)GRF specs. */

   210

			for (int i = 1; i < RECOLOUR_SPRITE_SIZE; i++) {

   211

				dest[i] = _palette_remap[dest_tmp[_palette_reverse_remap[i - 1] + 1]];

   212

			}

   213

		} else {

   214

			FioReadBlock(dest, num);

   215

		}

   216

   217

		return sc->ptr;

   218

	}

   219

	/* Ugly hack to work around the problem that the old landscape

   220

	 *  generator assumes that those sprites are stored uncompressed in

   221

	 *  the memory, and they are only read directly by the code, never

   222

	 *  send to the blitter. So do not send it to the blitter (which will

   223

	 *  result in a data array in the format the blitter likes most), but

   224

	 *  read the data directly from disk and store that as sprite.

   225

	 * Ugly: yes. Other solution: no. Blame the original author or

   226

	 *  something ;) The image should really have been a data-stream

   227

	 *  (so type = 0xFF basicly). */

   228

	assert((id >= 4845 && id <= 4881) == (sprite_type == ST_MAPGEN));

   229

	if (sprite_type == ST_MAPGEN) {

   230

		uint height = FioReadByte();

   231

		uint width  = FioReadWord();

   232

		Sprite *sprite;

   233

		byte *dest;

   234

   235

		num = width * height;

   236

		sprite = (Sprite *)AllocSprite(sizeof(*sprite) + num);

   237

		sc->ptr = sprite;

   238

		sprite->height = height;

   239

		sprite->width  = width;

   240

		sprite->x_offs = FioReadWord();

   241

		sprite->y_offs = FioReadWord();

   242

   243

		dest = sprite->data;

   244

		while (num > 0) {

   245

			int8 i = FioReadByte();

   246

			if (i >= 0) {

   247

				num -= i;

   248

				for (; i > 0; --i) *dest++ = FioReadByte();

   249

			} else {

   250

				const byte* rel = dest - (((i & 7) << 8) | FioReadByte());

   251

				i = -(i >> 3);

   252

				num -= i;

   253

				for (; i > 0; --i) *dest++ = *rel++;

   254

			}

   255

		}

   256

   257

		sc->type = sprite_type;

   258

   259

		return sc->ptr;

   260

	}

   261

   262

	if (sprite_type == ST_RECOLOUR) {

   263

		static byte warning_level = 0;

   264

		DEBUG(sprite, warning_level, "Tried to load real sprite #%d as a recolour sprite. Probable cause: NewGRF interference", id);

   265

		warning_level = 6;

   266

		return (void*)GetRawSprite(id, ST_NORMAL);

   267

	}

   268

   269

	SpriteLoaderGrf sprite_loader;

   270

	SpriteLoader::Sprite sprite;

   271

   272

	sc->type = sprite_type;

   273

   274

	if (!sprite_loader.LoadSprite(&sprite, file_slot, file_pos, sprite_type)) {

   275

		if (id == SPR_IMG_QUERY) usererror("Okay... something went horribly wrong. I couldn't load the fallback sprite. What should I do?");

   276

		return (void*)GetRawSprite(SPR_IMG_QUERY, ST_NORMAL);

   277

	}

   278

	sc->ptr = BlitterFactoryBase::GetCurrentBlitter()->Encode(&sprite, &AllocSprite);

   279

	free(sprite.data);

   280

   281

	return sc->ptr;

   282

}

   283

   284

   285

bool LoadNextSprite(int load_index, byte file_slot, uint file_sprite_id)

   286

{

   287

	SpriteCache *sc;

   288

	size_t file_pos = FioGetPos();

   289

   290

	if (!ReadSpriteHeaderSkipData()) return false;

   291

   292

	if (load_index >= MAX_SPRITES) {

   293

		usererror("Tried to load too many sprites (#%d; max %d)", load_index, MAX_SPRITES);

   294

	}

   295

   296

	sc = AllocateSpriteCache(load_index);

   297

	sc->file_slot = file_slot;

   298

	sc->file_pos = file_pos;

   299

	sc->ptr = NULL;

   300

	sc->lru = 0;

   301

	sc->id = file_sprite_id;

   302

	sc->type = ST_NORMAL;

   303

   304

	return true;

   305

}

   306

   307

   308

void DupSprite(SpriteID old_spr, SpriteID new_spr)

   309

{

   310

	SpriteCache *scnew = AllocateSpriteCache(new_spr); // may reallocate: so put it first

   311

	SpriteCache *scold = GetSpriteCache(old_spr);

   312

   313

	scnew->file_slot = scold->file_slot;

   314

	scnew->file_pos = scold->file_pos;

   315

	scnew->ptr = NULL;

   316

	scnew->id = scold->id;

   317

	scnew->type = scold->type;

   318

}

   319

   320

   321

#define S_FREE_MASK 1

   322

   323

static inline MemBlock* NextBlock(MemBlock* block)

   324

{

   325

	return (MemBlock*)((byte*)block + (block->size & ~S_FREE_MASK));

   326

}

   327

   328

static size_t GetSpriteCacheUsage()

   329

{

   330

	size_t tot_size = 0;

   331

	MemBlock* s;

   332

   333

	for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {

   334

		if (!(s->size & S_FREE_MASK)) tot_size += s->size;

   335

	}

   336

   337

	return tot_size;

   338

}

   339

   340

   341

void IncreaseSpriteLRU()

   342

{

   343

	/* Increase all LRU values */

   344

	if (_sprite_lru_counter > 16384) {

   345

		SpriteID i;

   346

   347

		DEBUG(sprite, 3, "Fixing lru %d, inuse=%d", _sprite_lru_counter, GetSpriteCacheUsage());

   348

   349

		for (i = 0; i != _spritecache_items; i++) {

   350

			SpriteCache *sc = GetSpriteCache(i);

   351

			if (sc->ptr != NULL) {

   352

				if (sc->lru >= 0) {

   353

					sc->lru = -1;

   354

				} else if (sc->lru != -32768) {

   355

					sc->lru--;

   356

				}

   357

			}

   358

		}

   359

		_sprite_lru_counter = 0;

   360

	}

   361

   362

	/* Compact sprite cache every now and then. */

   363

	if (++_compact_cache_counter >= 740) {

   364

		CompactSpriteCache();

   365

		_compact_cache_counter = 0;

   366

	}

   367

}

   368

   369

/** Called when holes in the sprite cache should be removed.

   370

 * That is accomplished by moving the cached data. */

   371

static void CompactSpriteCache()

   372

{

   373

	MemBlock *s;

   374

   375

	DEBUG(sprite, 3, "Compacting sprite cache, inuse=%d", GetSpriteCacheUsage());

   376

   377

	for (s = _spritecache_ptr; s->size != 0;) {

   378

		if (s->size & S_FREE_MASK) {

   379

			MemBlock* next = NextBlock(s);

   380

			MemBlock temp;

   381

			SpriteID i;

   382

   383

			/* Since free blocks are automatically coalesced, this should hold true. */

   384

			assert(!(next->size & S_FREE_MASK));

   385

   386

			/* If the next block is the sentinel block, we can safely return */

   387

			if (next->size == 0) break;

   388

   389

			/* Locate the sprite belonging to the next pointer. */

   390

			for (i = 0; GetSpriteCache(i)->ptr != next->data; i++) {

   391

				assert(i != _spritecache_items);

   392

			}

   393

   394

			GetSpriteCache(i)->ptr = s->data; // Adjust sprite array entry

   395

			/* Swap this and the next block */

   396

			temp = *s;

   397

			memmove(s, next, next->size);

   398

			s = NextBlock(s);

   399

			*s = temp;

   400

   401

			/* Coalesce free blocks */

   402

			while (NextBlock(s)->size & S_FREE_MASK) {

   403

				s->size += NextBlock(s)->size & ~S_FREE_MASK;

   404

			}

   405

		} else {

   406

			s = NextBlock(s);

   407

		}

   408

	}

   409

}

   410

   411

static void DeleteEntryFromSpriteCache()

   412

{

   413

	SpriteID i;

   414

	uint best = UINT_MAX;

   415

	MemBlock* s;

   416

	int cur_lru;

   417

   418

	DEBUG(sprite, 3, "DeleteEntryFromSpriteCache, inuse=%d", GetSpriteCacheUsage());

   419

   420

	cur_lru = 0xffff;

   421

	for (i = 0; i != _spritecache_items; i++) {

   422

		SpriteCache *sc = GetSpriteCache(i);

   423

		if (sc->ptr != NULL && sc->lru < cur_lru) {

   424

			cur_lru = sc->lru;

   425

			best = i;

   426

		}

   427

	}

   428

   429

	/* Display an error message and die, in case we found no sprite at all.

   430

	 * This shouldn't really happen, unless all sprites are locked. */

   431

	if (best == UINT_MAX) error("Out of sprite memory");

   432

   433

	/* Mark the block as free (the block must be in use) */

   434

	s = (MemBlock*)GetSpriteCache(best)->ptr - 1;

   435

	assert(!(s->size & S_FREE_MASK));

   436

	s->size |= S_FREE_MASK;

   437

	GetSpriteCache(best)->ptr = NULL;

   438

   439

	/* And coalesce adjacent free blocks */

   440

	for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {

   441

		if (s->size & S_FREE_MASK) {

   442

			while (NextBlock(s)->size & S_FREE_MASK) {

   443

				s->size += NextBlock(s)->size & ~S_FREE_MASK;

   444

			}

   445

		}

   446

	}

   447

}

   448

   449

void* AllocSprite(size_t mem_req)

   450

{

   451

	mem_req += sizeof(MemBlock);

   452

   453

	/* Align this to an uint32 boundary. This also makes sure that the 2 least

   454

	 * bits are not used, so we could use those for other things. */

   455

	mem_req = Align(mem_req, sizeof(uint32));

   456

   457

	for (;;) {

   458

		MemBlock* s;

   459

   460

		for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {

   461

			if (s->size & S_FREE_MASK) {

   462

				size_t cur_size = s->size & ~S_FREE_MASK;

   463

   464

				/* Is the block exactly the size we need or

   465

				 * big enough for an additional free block? */

   466

				if (cur_size == mem_req ||

   467

						cur_size >= mem_req + sizeof(MemBlock)) {

   468

					/* Set size and in use */

   469

					s->size = mem_req;

   470

   471

					/* Do we need to inject a free block too? */

   472

					if (cur_size != mem_req) {

   473

						NextBlock(s)->size = (cur_size - mem_req) | S_FREE_MASK;

   474

					}

   475

   476

					return s->data;

   477

				}

   478

			}

   479

		}

   480

   481

		/* Reached sentinel, but no block found yet. Delete some old entry. */

   482

		DeleteEntryFromSpriteCache();

   483

	}

   484

}

   485

   486