1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "gfx.h"

     8

#include "spritecache.h"

     9

#include "table/sprites.h"

    10

#include "fileio.h"

    11

#include "newgrf.h"

    12

#include "md5.h"

    13

#include "variables.h"

    14

#include <ctype.h>

    15

    16

#define SPRITE_CACHE_SIZE 1024*1024

    17

    18

#define WANT_NEW_LRU

    19

    20

    21

/* These are used in newgrf.c: */

    22

    23

int _skip_sprites = 0;

    24

int _replace_sprites_count[16];

    25

int _replace_sprites_offset[16];

    26

    27

static const char *_cur_grffile;

    28

static int _loading_stage;

    29

static int _skip_specials;

    30

uint16 _custom_sprites_base;

    31

static Sprite _cur_sprite;

    32

    33

    34

static void* _sprite_ptr[MAX_SPRITES];

    35

static uint32 _sprite_file_pos[MAX_SPRITES];

    36

    37

#if defined(WANT_NEW_LRU)

    38

static int16 _sprite_lru_new[MAX_SPRITES];

    39

#else

    40

static uint16 _sprite_lru[MAX_SPRITES];

    41

static uint16 _sprite_lru_cur[MAX_SPRITES];

    42

#endif

    43

    44

typedef struct MemBlock {

    45

	uint32 size;

    46

	byte data[VARARRAY_SIZE];

    47

} MemBlock;

    48

    49

static uint _sprite_lru_counter;

    50

static MemBlock *_spritecache_ptr;

    51

static int _compact_cache_counter;

    52

    53

typedef struct MD5File {

    54

	const char * const filename;     // filename

    55

	const md5_byte_t hash[16]; // md5 sum of the file

    56

} MD5File;

    57

    58

typedef struct FileList {

    59

	const MD5File basic[5];     // grf files that always have to be loaded

    60

	const MD5File landscape[3]; // landscape specific grf files

    61

} FileList;

    62

    63

#include "table/files.h"

    64

#include "table/landscape_sprite.h"

    65

    66

static const SpriteID * const _landscape_spriteindexes[] = {

    67

	_landscape_spriteindexes_1,

    68

	_landscape_spriteindexes_2,

    69

	_landscape_spriteindexes_3,

    70

};

    71

    72

static const SpriteID * const _slopes_spriteindexes[] = {

    73

	_slopes_spriteindexes_0,

    74

	_slopes_spriteindexes_1,

    75

	_slopes_spriteindexes_2,

    76

	_slopes_spriteindexes_3,

    77

};

    78

    79

static void CompactSpriteCache(void);

    80

    81

static void ReadSpriteHeaderSkipData(int num, int load_index)

    82

{

    83

	byte type;

    84

	int deaf = 0;

    85

    86

	if (_skip_sprites) {

    87

		if (_skip_sprites > 0)

    88

			_skip_sprites--;

    89

		deaf = 1;

    90

	}

    91

    92

	type = FioReadByte();

    93

	_cur_sprite.info = type;

    94

	if (type == 0xFF) {

    95

		/* We need to really skip only special sprites in the deaf

    96

		 * mode.  It won't hurt to proceed regular sprites as usual

    97

		 * because if no special sprite referencing to them is

    98

		 * processed, they themselves are never referenced and loaded

    99

		 * on their own. */

   100

		if (_skip_specials || deaf) {

   101

			FioSkipBytes(num);

   102

		} else {

   103

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   104

		}

   105

		return;

   106

	}

   107

   108

	FioSkipBytes(7);

   109

	num -= 8;

   110

	if (num == 0)

   111

		return;

   112

   113

	if (type & 2) {

   114

		FioSkipBytes(num);

   115

	} else {

   116

		while (num > 0) {

   117

			int8 i = FioReadByte();

   118

			if (i >= 0) {

   119

				num -= i;

   120

				FioSkipBytes(i);

   121

			} else {

   122

				i = -(i >> 3);

   123

				num -= i;

   124

				FioReadByte();

   125

			}

   126

		}

   127

	}

   128

}

   129

   130

static void* AllocSprite(size_t);

   131

   132

static void* ReadSprite(SpriteID id)

   133

{

   135

	byte type;

   136

   137

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

   138

   140

		error(

   141

			"Tried to load non-existing sprite #%d.\n"

   142

			"Probable cause: Wrong/missing NewGRFs",

   143

			id

   144

		);

   145

	}

   146

   147

	FioSeekToFile(_sprite_file_pos[id]);

   148

   150

	type = FioReadByte();

   151

	if (type == 0xFF) {

   152

		byte* dest = AllocSprite(num);

   153

   154

		_sprite_ptr[id] = dest;

   155

		FioReadBlock(dest, num);

   156

   157

		return dest;

   158

	} else {

   159

		uint height = FioReadByte();

   160

		uint width  = FioReadWord();

   161

		Sprite* sprite;

   162

		byte* dest;

   163

   164

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

   165

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

   166

		_sprite_ptr[id] = sprite;

   167

		sprite->info   = type;

   168

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

   169

		sprite->width  = width;

   170

		sprite->x_offs = FioReadWord();

   171

		sprite->y_offs = FioReadWord();

   172

   173

		dest = sprite->data;

   174

		while (num > 0) {

   175

			int8 i = FioReadByte();

   176

   177

			if (i >= 0) {

   178

				num -= i;

   179

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

   180

			} else {

   181

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

   182

   183

				i = -(i >> 3);

   184

				num -= i;

   185

   186

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

   187

			}

   188

		}

   189

   190

		return sprite;

   191

	}

   192

}

   193

   194

   195

static bool LoadNextSprite(int load_index, byte file_index)

   196

{

   199

   201

   202

	ReadSpriteHeaderSkipData(size, load_index);

   203

   204

	if (_replace_sprites_count[0] > 0 && _cur_sprite.info != 0xFF) {

   205

		int count = _replace_sprites_count[0];

   206

		int offset = _replace_sprites_offset[0];

   207

   208

		_replace_sprites_offset[0]++;

   209

		_replace_sprites_count[0]--;

   210

   211

		if ((offset + count) <= MAX_SPRITES) {

   212

			load_index = offset;

   213

		} else {

   214

			DEBUG(spritecache, 1) ("Sprites to be replaced are out of range: %x+%x",

   215

					count, offset);

   216

			_replace_sprites_offset[0] = 0;

   217

			_replace_sprites_count[0] = 0;

   218

		}

   219

   220

		if (_replace_sprites_count[0] == 0) {

   221

			int i;

   222

   223

			for (i = 0; i < 15; i++) {

   224

				_replace_sprites_count[i] = _replace_sprites_count[i + 1];

   225

				_replace_sprites_offset[i] = _replace_sprites_offset[i + 1];

   226

			}

   227

			_replace_sprites_count[i] = 0;

   228

			_replace_sprites_offset[i] = 0;

   229

		}

   230

	}

   231

   232

	_sprite_file_pos[load_index] = file_pos;

   233

   234

	_sprite_ptr[load_index] = NULL;

   235

   236

#if defined(WANT_NEW_LRU)

   237

	_sprite_lru_new[load_index] = 0;

   238

#else

   239

	_sprite_lru[load_index] = 0xFFFF;

   240

	_sprite_lru_cur[load_index] = 0;

   241

#endif

   242

   243

	return true;

   244

}

   245

   246

static void SkipSprites(uint count)

   247

{

   248

	for (; count > 0; --count)

   249

	{

   250

		uint16 size = FioReadWord();

   251

   252

		if (size == 0)

   253

			return;

   254

   255

		ReadSpriteHeaderSkipData(size, MAX_SPRITES - 1);

   256

	}

   257

}

   258

   259

static int LoadGrfFile(const char *filename, int load_index, int file_index)

   260

{

   261

	int load_index_org = load_index;

   262

   263

	FioOpenFile(file_index, filename);

   264

   265

	/* Thou shalt use LoadNewGrfFile() if thou loadeth a GRF file that

   266

	 * might contain some special sprites. */

   267

	_skip_specials = 1;

   268

	_skip_sprites = 0;

   269

   270

	DEBUG(spritecache, 2) ("Reading grf-file ``%s''", filename);

   271

   272

	while (LoadNextSprite(load_index, file_index)) {

   273

		load_index++;

   274

		if (load_index >= MAX_SPRITES) {

   275

			error("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");

   276

		}

   277

	}

   278

	DEBUG(spritecache, 2) ("Currently %i sprites are loaded", load_index);

   279

   280

	return load_index - load_index_org;

   281

}

   282

   283

static int LoadNewGrfFile(const char *filename, int load_index, int file_index)

   284

{

   285

	int i;

   286

   287

	FioOpenFile(file_index, filename);

   288

	_cur_grffile = filename;

   289

	_skip_specials = 0;

   290

	_skip_sprites = 0;

   291

   292

	DEBUG(spritecache, 2) ("Reading newgrf-file ``%s'' [offset: %u]",

   293

			filename, load_index);

   294

   295

	/* Skip the first sprite; we don't care about how many sprites this

   296

	 * does contain; newest TTDPatches and George's longvehicles don't

   297

	 * neither, apparently. */

   298

	{

   299

		int length;

   300

		byte type;

   301

   302

		length = FioReadWord();

   303

		type = FioReadByte();

   304

   305

		if (length == 4 && type == 0xFF) {

   306

			FioReadDword();

   307

		} else {

   308

			error("Custom .grf has invalid format.");

   309

		}

   310

	}

   311

   312

	for (i = 0; LoadNextSprite(load_index + i, file_index); i++) {

   313

		if (load_index + i >= MAX_SPRITES)

   314

			error("Too many sprites (0x%X). Recompile with higher MAX_SPRITES value or remove some custom GRF files.",

   315

			      load_index + i);

   316

	}

   317

   318

	/* Clean up. */

   319

	_skip_sprites = 0;

   320

	memset(_replace_sprites_count, 0, sizeof(_replace_sprites_count));

   321

	memset(_replace_sprites_offset, 0, sizeof(_replace_sprites_offset));

   322

   323

	return i;

   324

}

   325

   326

static void LoadGrfIndexed(const char *filename, const SpriteID *index_tbl, int file_index)

   327

{

   328

	int start;

   329

   330

	FioOpenFile(file_index, filename);

   331

	_skip_specials = 1;

   332

	_skip_sprites = 0;

   333

   334

	DEBUG(spritecache, 2) ("Reading indexed grf-file ``%s''", filename);

   335

   336

	for (; (start = *index_tbl++) != 0xffff;) {

   337

		int end = *index_tbl++;

   338

		if(start == 0xfffe) { // skip sprites (amount in second var)

   339

			SkipSprites(end);

   340

		} else { // load sprites and use indexes from start to end

   341

			do {

   342

			#ifdef NDEBUG

   343

				LoadNextSprite(start, file_index);

   344

			#else

   345

				bool b = LoadNextSprite(start, file_index);

   346

				assert(b);

   347

			#endif

   348

			} while (++start <= end);

   349

		}

   350

	}

   351

}

   352

   353

   354

#define S_FREE_MASK 1

   355

   356

static inline MemBlock* NextBlock(MemBlock* block)

   357

{

   358

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

   359

}

   360

   361

static uint32 GetSpriteCacheUsage(void)

   362

{

   363

	size_t tot_size = 0;

   364

	MemBlock* s;

   365

   366

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

   367

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

   368

   369

	return tot_size;

   370

}

   371

   372

   373

void IncreaseSpriteLRU(void)

   374

{

   375

	int i;

   376

   377

	// Increase all LRU values

   378

#if defined(WANT_NEW_LRU)

   379

	if (_sprite_lru_counter > 16384) {

   380

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

   381

   382

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

   383

			if (_sprite_ptr[i] != NULL) {

   384

				if (_sprite_lru_new[i] >= 0) {

   385

					_sprite_lru_new[i] = -1;

   386

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

   387

					_sprite_lru_new[i]--;

   388

				}

   389

			}

   390

		_sprite_lru_counter = 0;

   391

	}

   392

#else

   393

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

   394

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

   395

			_sprite_lru[i]++;

   396

	// Reset the lru counter.

   397

	_sprite_lru_counter = 0;

   398

#endif

   399

   400

	// Compact sprite cache every now and then.

   401

	if (++_compact_cache_counter >= 740) {

   402

		CompactSpriteCache();

   403

		_compact_cache_counter = 0;

   404

	}

   405

}

   406

   407

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

   408

// That is accomplished by moving the cached data.

   409

static void CompactSpriteCache(void)

   410

{

   411

	MemBlock *s;

   412

   413

	DEBUG(spritecache, 2) (

   414

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

   415

	);

   416

   417

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

   418

		if (s->size & S_FREE_MASK) {

   419

			MemBlock* next = NextBlock(s);

   420

			MemBlock temp;

   421

			void** i;

   422

   423

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

   424

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

   425

   426

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

   427

			if (next->size == 0)

   428

				break;

   429

   430

			// Locate the sprite belonging to the next pointer.

   431

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

   432

				assert(i != endof(_sprite_ptr));

   433

			}

   434

   435

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

   436

			// Swap this and the next block

   437

			temp = *s;

   438

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

   439

			s = NextBlock(s);

   440

			*s = temp;

   441

   442

			// Coalesce free blocks

   443

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

   444

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

   445

			}

   446

		} else {

   447

			s = NextBlock(s);

   448

		}

   449

	}

   450

}

   451

   452

static void DeleteEntryFromSpriteCache(void)

   453

{

   454

	int i;

   455

	int best = -1;

   456

	MemBlock* s;

   457

	int cur_lru;

   458

   459

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

   460

   461

#if defined(WANT_NEW_LRU)

   462

	cur_lru = 0xffff;

   463

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

   464

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

   465

			cur_lru = _sprite_lru_new[i];

   466

			best = i;

   467

		}

   468

	}

   469

#else

   470

	{

   471

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   472

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

   473

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

   474

   475

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

   476

		if (_sprite_lru[i] != cur_lru) {

   477

			cur_lru = _sprite_lru[i];

   478

			best = i;

   479

   480

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

   481

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

   482

			cur_lru_cur = _sprite_lru_cur[i];

   483

			cur_lru = _sprite_lru[i];

   484

			best = i;

   485

		}

   486

	}

   487

	}

   488

#endif

   489

   490

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

   491

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

   492

	if (best == -1)

   493

		error("Out of sprite memory");

   494

   495

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

   496

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