1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "macros.h"

     8

#include "spritecache.h"

     9

#include "table/sprites.h"

    10

#include "fileio.h"

    11

    12

#ifndef SPRITE_CACHE_SIZE

    13

# define SPRITE_CACHE_SIZE 2*1024*1024

    14

#endif /* SPRITE_CACHE_SIZE */

    15

    16

#define WANT_NEW_LRU

    17

    18

    19

static void* _sprite_ptr[MAX_SPRITES];

    20

static uint32 _sprite_file_pos[MAX_SPRITES];

    21

    22

#if defined(WANT_NEW_LRU)

    23

static int16 _sprite_lru_new[MAX_SPRITES];

    24

#else

    25

static uint16 _sprite_lru[MAX_SPRITES];

    26

static uint16 _sprite_lru_cur[MAX_SPRITES];

    27

#endif

    28

    29

typedef struct MemBlock {

    30

	uint32 size;

    31

	byte data[VARARRAY_SIZE];

    32

} MemBlock;

    33

    34

static uint _sprite_lru_counter;

    35

static MemBlock *_spritecache_ptr;

    36

static int _compact_cache_counter;

    37

    38

static void CompactSpriteCache(void);

    39

    40

static bool ReadSpriteHeaderSkipData(void)

    41

{

    42

	uint16 num = FioReadWord();

    43

	byte type;

    44

    45

	if (num == 0) return false;

    46

    47

	type = FioReadByte();

    48

	if (type == 0xFF) {

    49

		FioSkipBytes(num);

    50

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

    51

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

    52

		return num != 1;

    53

	}

    54

    55

	FioSkipBytes(7);

    56

	num -= 8;

    57

	if (num == 0) return true;

    58

    59

	if (type & 2) {

    60

		FioSkipBytes(num);

    61

	} else {

    62

		while (num > 0) {

    63

			int8 i = FioReadByte();

    64

			if (i >= 0) {

    65

				num -= i;

    66

				FioSkipBytes(i);

    67

			} else {

    68

				i = -(i >> 3);

    69

				num -= i;

    70

				FioReadByte();

    71

			}

    72

		}

    73

	}

    74

    75

	return true;

    76

}

    77

    78

/* Check if the given Sprite ID exists */

    79

bool SpriteExists(SpriteID id)

    80

{

    81

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

    82

	return _sprite_file_pos[id] != 0 || id == 0;

    83

}

    84

    85

static void* AllocSprite(size_t);

    86

    87

static void* ReadSprite(SpriteID id, bool real_sprite)

    88

{

    89

	uint num;

    90

	byte type;

    91

	uint32 filepos = _sprite_file_pos[id];

    92

    93

	DEBUG(spritecache, 9) ("load sprite %d", id);

    94

    95

	if (!SpriteExists(id)) {

    96

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

    97

    98

		/* SPR_IMG_QUERY is a BIG FAT RED ? */

    99

		filepos = _sprite_file_pos[SPR_IMG_QUERY];

   100

	}

   101

   102

	FioSeekToFile(filepos);

   103

   104

	num  = FioReadWord();

   105

	type = FioReadByte();

   106

	if (type == 0xFF) {

   107

		byte* dest;

   108

   109

		if (real_sprite) {

   110

			static byte warning_level = 0;

   111

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

   112

			warning_level = 6;

   113

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

   114

			return (void*)GetSprite(SPR_IMG_QUERY);

   115

		}

   116

   117

		dest = AllocSprite(num);

   118

   119

		_sprite_ptr[id] = dest;

   120

		FioReadBlock(dest, num);

   121

   122

		return dest;

   123

	} else {

   124

		uint height = FioReadByte();

   125

		uint width  = FioReadWord();

   126

		Sprite* sprite;

   127

		byte* dest;

   128

   129

		if (!real_sprite) {

   130

			static byte warning_level = 0;

   131

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

   132

			warning_level = 6;

   133

		}

   134

   135

		num = (type & 0x02) ? width * height : num - 8;

   136

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

   137

		_sprite_ptr[id] = sprite;

   138

		sprite->info   = type;

   139

		sprite->height = (id != 142) ? height : 10; // Compensate for a TTD bug

   140

		sprite->width  = width;

   141

		sprite->x_offs = FioReadWord();

   142

		sprite->y_offs = FioReadWord();

   143

   144

		dest = sprite->data;

   145

		while (num > 0) {

   146

			int8 i = FioReadByte();

   147

   148

			if (i >= 0) {

   149

				num -= i;

   150

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

   151

			} else {

   152

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

   153

   154

				i = -(i >> 3);

   155

				num -= i;

   156

   157

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

   158

			}

   159

		}

   160

   161

		return sprite;

   162

	}

   163

}

   164

   165

   166

bool LoadNextSprite(int load_index, byte file_index)

   167

{

   168

	uint32 file_pos = FioGetPos() | (file_index << 24);

   169

   170

	if (!ReadSpriteHeaderSkipData()) return false;

   171

   172

	if (load_index >= MAX_SPRITES) {

   173

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

   174

	}

   175

   176

	_sprite_file_pos[load_index] = file_pos;

   177

   178

	_sprite_ptr[load_index] = NULL;

   179

   180

#if defined(WANT_NEW_LRU)

   181

	_sprite_lru_new[load_index] = 0;

   182

#else

   183

	_sprite_lru[load_index] = 0xFFFF;

   184

	_sprite_lru_cur[load_index] = 0;

   185

#endif

   186

   187

	return true;

   188

}

   189

   190

   191

void DupSprite(SpriteID old, SpriteID new)

   192

{

   193

	_sprite_file_pos[new] = _sprite_file_pos[old];

   194

	_sprite_ptr[new] = NULL;

   195

}

   196

   197

   198

void SkipSprites(uint count)

   199

{

   200

	for (; count > 0; --count) {

   201

		if (!ReadSpriteHeaderSkipData()) return;

   202

	}

   203

}

   204

   205

   206

#define S_FREE_MASK 1

   207

   208

static inline MemBlock* NextBlock(MemBlock* block)

   209

{

   210

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

   211

}

   212

   213

static uint32 GetSpriteCacheUsage(void)

   214

{

   215

	uint32 tot_size = 0;

   216

	MemBlock* s;

   217

   218

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

   219

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

   220

   221

	return tot_size;

   222

}

   223

   224

   225

void IncreaseSpriteLRU(void)

   226

{

   227

	int i;

   228

   229

	// Increase all LRU values

   230

#if defined(WANT_NEW_LRU)

   231

	if (_sprite_lru_counter > 16384) {

   232

		DEBUG(spritecache, 2) ("fixing lru %d, inuse=%d", _sprite_lru_counter, GetSpriteCacheUsage());

   233

   234

		for (i = 0; i != MAX_SPRITES; i++)

   235

			if (_sprite_ptr[i] != NULL) {

   236

				if (_sprite_lru_new[i] >= 0) {

   237

					_sprite_lru_new[i] = -1;

   238

				} else if (_sprite_lru_new[i] != -32768) {

   239

					_sprite_lru_new[i]--;

   240

				}

   241

			}

   242

		_sprite_lru_counter = 0;

   243

	}

   244

#else

   245

	for (i = 0; i != MAX_SPRITES; i++)

   246

		if (_sprite_ptr[i] != NULL && _sprite_lru[i] != 65535)

   247

			_sprite_lru[i]++;

   248

	// Reset the lru counter.

   249

	_sprite_lru_counter = 0;

   250

#endif

   251

   252

	// Compact sprite cache every now and then.

   253

	if (++_compact_cache_counter >= 740) {

   254

		CompactSpriteCache();

   255

		_compact_cache_counter = 0;

   256

	}

   257

}

   258

   259

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

   260

// That is accomplished by moving the cached data.

   261

static void CompactSpriteCache(void)

   262

{

   263

	MemBlock *s;

   264

   265

	DEBUG(spritecache, 2) (

   266

		"compacting sprite cache, inuse=%d", GetSpriteCacheUsage()

   267

	);

   268

   269

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

   270

		if (s->size & S_FREE_MASK) {

   271

			MemBlock* next = NextBlock(s);

   272

			MemBlock temp;

   273

			void** i;

   274

   275

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

   276

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

   277

   278

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

   279

			if (next->size == 0)

   280

				break;

   281

   282

			// Locate the sprite belonging to the next pointer.

   283

			for (i = _sprite_ptr; *i != next->data; ++i) {

   284

				assert(i != endof(_sprite_ptr));

   285

			}

   286

   287

			*i = s->data; // Adjust sprite array entry

   288

			// Swap this and the next block

   289

			temp = *s;

   290

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

   291

			s = NextBlock(s);

   292

			*s = temp;

   293

   294

			// Coalesce free blocks

   295

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

   296

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

   297

			}

   298

		} else {

   299

			s = NextBlock(s);

   300

		}

   301

	}

   302

}

   303

   304

static void DeleteEntryFromSpriteCache(void)

   305

{

   306

	int i;

   307

	int best = -1;

   308

	MemBlock* s;

   309

	int cur_lru;

   310

   311

	DEBUG(spritecache, 2) ("DeleteEntryFromSpriteCache, inuse=%d", GetSpriteCacheUsage());

   312

   313

#if defined(WANT_NEW_LRU)

   314

	cur_lru = 0xffff;

   315

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

   316

		if (_sprite_ptr[i] != NULL && _sprite_lru_new[i] < cur_lru) {

   317

			cur_lru = _sprite_lru_new[i];

   318

			best = i;

   319

		}

   320

	}

   321

#else

   322

	{

   323

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   324

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

   325

		if (_sprite_ptr[i] == NULL || _sprite_lru[i] < cur_lru) continue;

   326

   327

		// Found a sprite with a higher LRU value, then remember it.

   328

		if (_sprite_lru[i] != cur_lru) {

   329

			cur_lru = _sprite_lru[i];

   330

			best = i;

   331

   332

		// Else if both sprites were very recently referenced, compare by the cur value instead.

   333

		} else if (cur_lru == 0 && _sprite_lru_cur[i] <= cur_lru_cur) {

   334

			cur_lru_cur = _sprite_lru_cur[i];

   335

			cur_lru = _sprite_lru[i];

   336

			best = i;

   337

		}

   338

	}

   339

	}

   340

#endif

   341

   342

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

   343

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

   344

	if (best == -1)

   345

		error("Out of sprite memory");

   346

   347

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

   348

	s = (MemBlock*)_sprite_ptr[best] - 1;

   349

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

   350

	s->size |= S_FREE_MASK;

   351

	_sprite_ptr[best] = NULL;

   352

   353

	// And coalesce adjacent free blocks

   354

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

   355

		if (s->size & S_FREE_MASK) {

   356

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

   357

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

   358

			}

   359

		}

   360

	}

   361

}

   362

   363

static void* AllocSprite(size_t mem_req)

   364

{

   365

	mem_req += sizeof(MemBlock);

   366

   367

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

   368

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

   369

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

   370

   371

	for (;;) {

   372

		MemBlock* s;

   373

   374

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

   375

			if (s->size & S_FREE_MASK) {

   376

				size_t cur_size = s->size & ~S_FREE_MASK;

   377

   378

				/* Is the block exactly the size we need or

   379

				 * big enough for an additional free block? */

   380

				if (cur_size == mem_req ||

   381

						cur_size >= mem_req + sizeof(MemBlock)) {

   382

					// Set size and in use

   383

					s->size = mem_req;

   384

   385

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

   386

					if (cur_size != mem_req) {

   387

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

   388

					}

   389

   390

					return s->data;

   391

				}

   392

			}

   393

		}

   394

   395

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

   396

		DeleteEntryFromSpriteCache();

   397

	}

   398

}

   399

   400

#if defined(NEW_ROTATION)

   401

#define X15(x) else if (s >= x && s < (x+15)) { s = _rotate_tile_sprite[s - x] + x; }

   402

#define X19(x) else if (s >= x && s < (x+19)) { s = _rotate_tile_sprite[s - x] + x; }

   403

#define MAP(from,to,map) else if (s >= from && s <= to) { s = map[s - from] + from; }

   404

   405

   406

static uint RotateSprite(uint s)

   407

{

   408

	static const byte _rotate_tile_sprite[19] = { 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 17, 18, 16, 15 };

   409

	static const byte _coast_map[9] = {0, 4, 3, 1, 2, 6, 8, 5, 7};

   410

	static const byte _fence_map[6] = {1, 0, 5, 4, 3, 2};

   411

   412

	if (0);

   413

	X19(752)

   414

	X15(990-1)

   415

	X19(3924)

   416

	X19(3943)

   417

	X19(3962)

   418

	X19(3981)

   419

	X19(4000)

   420

	X19(4023)

   421

	X19(4042)

   422

	MAP(4061, 4069, _coast_map)

   423

	X19(4126)

   424

	X19(4145)

   425

	X19(4164)

   426

	X19(4183)

   427

	X19(4202)

   428

	X19(4221)

   429

	X19(4240)

   430

	X19(4259)

   431

	X19(4259)

   432

	X19(4278)

   433

	MAP(4090, 4095, _fence_map)

   434

	MAP(4096, 4101, _fence_map)

   435

	MAP(4102, 4107, _fence_map)

   436

	MAP(4108, 4113, _fence_map)

   437

	MAP(4114, 4119, _fence_map)

   438

	MAP(4120, 4125, _fence_map)

   439

	return s;

   440

}

   441

#endif

   442

   443

const void *GetRawSprite(SpriteID sprite, bool real_sprite)

   444

{

   445

	void* p;

   446

   447

	assert(sprite < MAX_SPRITES);

   448

   449

#if defined(NEW_ROTATION)

   450

	sprite = RotateSprite(sprite);

   451

#endif

   452

   453

	// Update LRU

   454

#if defined(WANT_NEW_LRU)

   455

	_sprite_lru_new[sprite] = ++_sprite_lru_counter;

   456

#else

   457

	_sprite_lru_cur[sprite] = ++_sprite_lru_counter;

   458

	_sprite_lru[sprite] = 0;

   459

#endif

   460

   461

	p = _sprite_ptr[sprite];

   462

	// Load the sprite, if it is not loaded, yet

   463

	if (p == NULL) p = ReadSprite(sprite, real_sprite);

   464

	return p;

   465

}

   466

   467

   468

void GfxInitSpriteMem(void)

   469

{

   470

	// initialize sprite cache heap

   471

	if (_spritecache_ptr == NULL) _spritecache_ptr = malloc(SPRITE_CACHE_SIZE);

   472

   473

	// A big free block

   474

	_spritecache_ptr->size = (SPRITE_CACHE_SIZE - sizeof(MemBlock)) | S_FREE_MASK;

   475

	// Sentinel block (identified by size == 0)

   476

	NextBlock(_spritecache_ptr)->size = 0;

   477

   478

	memset(_sprite_ptr, 0, sizeof(_sprite_ptr));

   479

   480

	_compact_cache_counter = 0;

   481

}