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 uint16 _sprite_size[MAX_SPRITES];

    36

static uint32 _sprite_file_pos[MAX_SPRITES];

    37

    38

#if defined(WANT_NEW_LRU)

    39

static int16 _sprite_lru_new[MAX_SPRITES];

    40

#else

    41

static uint16 _sprite_lru[MAX_SPRITES];

    42

static uint16 _sprite_lru_cur[MAX_SPRITES];

    43

#endif

    44

    45

typedef struct MemBlock {

    46

	uint32 size;

    47

	byte data[VARARRAY_SIZE];

    48

} MemBlock;

    49

    50

static uint _sprite_lru_counter;

    51

static MemBlock *_spritecache_ptr;

    52

static uint32 _spritecache_size;

    53

static int _compact_cache_counter;

    54

    55

typedef struct MD5File {

    56

	const char * const filename;     // filename

    57

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

    58

} MD5File;

    59

    60

typedef struct FileList {

    61

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

    62

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

    63

} FileList;

    64

    65

#include "table/files.h"

    66

#include "table/landscape_sprite.h"

    67

    68

static const SpriteID * const _landscape_spriteindexes[] = {

    69

	_landscape_spriteindexes_1,

    70

	_landscape_spriteindexes_2,

    71

	_landscape_spriteindexes_3,

    72

};

    73

    74

static const SpriteID * const _slopes_spriteindexes[] = {

    75

	_slopes_spriteindexes_0,

    76

	_slopes_spriteindexes_1,

    77

	_slopes_spriteindexes_2,

    78

	_slopes_spriteindexes_3,

    79

};

    80

    81

static void CompactSpriteCache(void);

    82

    83

static void ReadSpriteHeaderSkipData(int num, int load_index)

    84

{

    85

	byte type;

    86

	int deaf = 0;

    87

    88

	if (_skip_sprites) {

    89

		if (_skip_sprites > 0)

    90

			_skip_sprites--;

    91

		deaf = 1;

    92

	}

    93

    94

	type = FioReadByte();

    95

	_cur_sprite.info = type;

    96

	if (type == 0xFF) {

    97

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

    98

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

    99

		 * because if no special sprite referencing to them is

   100

		 * processed, they themselves are never referenced and loaded

   101

		 * on their own. */

   102

		if (_skip_specials || deaf) {

   103

			FioSkipBytes(num);

   104

		} else {

   105

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   106

		}

   107

		return;

   108

	}

   109

   110

	FioSkipBytes(7);

   111

	num -= 8;

   112

	if (num == 0)

   113

		return;

   114

   115

	if (type & 2) {

   116

		FioSkipBytes(num);

   117

	} else {

   118

		while (num > 0) {

   119

			int8 i = FioReadByte();

   120

			if (i >= 0) {

   121

				num -= i;

   122

				FioSkipBytes(i);

   123

			} else {

   124

				i = -(i >> 3);

   125

				num -= i;

   126

				FioReadByte();

   127

			}

   128

		}

   129

	}

   130

}

   131

   132

static void* AllocSprite(size_t);

   133

   134

static void* ReadSprite(SpriteID id)

   135

{

   136

	uint num = _sprite_size[id];

   137

	byte type;

   138

   139

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

   140

   141

	if (_sprite_file_pos[id] == 0) {

   142

		error(

   143

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

   144

			"Probable cause: Wrong/missing NewGRFs",

   145

			id

   146

		);

   147

	}

   148

   149

	FioSeekToFile(_sprite_file_pos[id]);

   150

   151

	type = FioReadByte();

   152

	if (type == 0xFF) {

   153

		byte* dest = AllocSprite(num);

   154

   155

		_sprite_ptr[id] = dest;

   156

		FioReadBlock(dest, num);

   157

   158

		return dest;

   159

	} else {

   160

		uint height = FioReadByte();

   161

		uint width  = FioReadWord();

   162

		Sprite* sprite;

   163

		byte* dest;

   164

   165

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

   166

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

   167

		_sprite_ptr[id] = sprite;

   168

		sprite->info   = type;

   169

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

   170

		sprite->width  = width;

   171

		sprite->x_offs = FioReadWord();

   172

		sprite->y_offs = FioReadWord();

   173

   174

		dest = sprite->data;

   175

		while (num > 0) {

   176

			int8 i = FioReadByte();

   177

   178

			if (i >= 0) {

   179

				num -= i;

   180

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

   181

			} else {

   182

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

   183

   184

				i = -(i >> 3);

   185

				num -= i;

   186

   187

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

   188

			}

   189

		}

   190

   191

		return sprite;

   192

	}

   193

}

   194

   195

   196

static bool LoadNextSprite(int load_index, byte file_index)

   197

{

   198

	uint16 size;

   199

	uint32 file_pos;

   200

   201

	size = FioReadWord();

   202

	if (size == 0)

   203

		return false;

   204

   205

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

   206

   207

	ReadSpriteHeaderSkipData(size, load_index);

   208

   209

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

   210

		int count = _replace_sprites_count[0];

   211

		int offset = _replace_sprites_offset[0];

   212

   213

		_replace_sprites_offset[0]++;

   214

		_replace_sprites_count[0]--;

   215

   216

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

   217

			load_index = offset;

   218

		} else {

   219

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

   220

					count, offset);

   221

			_replace_sprites_offset[0] = 0;

   222

			_replace_sprites_count[0] = 0;

   223

		}

   224

   225

		if (_replace_sprites_count[0] == 0) {

   226

			int i;

   227

   228

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

   229

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

   230

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

   231

			}

   232

			_replace_sprites_count[i] = 0;

   233

			_replace_sprites_offset[i] = 0;

   234

		}

   235

	}

   236

   237

	_sprite_size[load_index] = size;

   238

	_sprite_file_pos[load_index] = file_pos;

   239

   240

	_sprite_ptr[load_index] = NULL;

   241

   242

#if defined(WANT_NEW_LRU)

   243

	_sprite_lru_new[load_index] = 0;

   244

#else

   245

	_sprite_lru[load_index] = 0xFFFF;

   246

	_sprite_lru_cur[load_index] = 0;

   247

#endif

   248

   249

	return true;

   250

}

   251

   252

static void SkipSprites(uint count)

   253

{

   254

	for (; count > 0; --count)

   255

	{

   256

		uint16 size = FioReadWord();

   257

   258

		if (size == 0)

   259

			return;

   260

   261

		ReadSpriteHeaderSkipData(size, MAX_SPRITES - 1);

   262

	}

   263

}

   264

   265

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

   266

{

   267

	int load_index_org = load_index;

   268

   269

	FioOpenFile(file_index, filename);

   270

   271

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

   272

	 * might contain some special sprites. */

   273

	_skip_specials = 1;

   274

	_skip_sprites = 0;

   275

   276

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

   277

   278

	while (LoadNextSprite(load_index, file_index)) {

   279

		load_index++;

   280

		if (load_index >= MAX_SPRITES) {

   281

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

   282

		}

   283

	}

   284

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

   285

   286

	return load_index - load_index_org;

   287

}

   288

   289

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

   290

{

   291

	int i;

   292

   293

	FioOpenFile(file_index, filename);

   294

	_cur_grffile = filename;

   295

	_skip_specials = 0;

   296

	_skip_sprites = 0;

   297

   298

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

   299

			filename, load_index);

   300

   301

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

   302

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

   303

	 * neither, apparently. */

   304

	{

   305

		int length;

   306

		byte type;

   307

   308

		length = FioReadWord();

   309

		type = FioReadByte();

   310

   311

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

   312

			FioReadDword();

   313

		} else {

   314

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

   315

		}

   316

	}

   317

   318

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

   319

		if (load_index + i >= MAX_SPRITES)

   320

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

   321

			      load_index + i);

   322

	}

   323

   324

	/* Clean up. */

   325

	_skip_sprites = 0;

   326

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

   327

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

   328

   329

	return i;

   330

}

   331

   332

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

   333

{

   334

	int start;

   335

   336

	FioOpenFile(file_index, filename);

   337

	_skip_specials = 1;

   338

	_skip_sprites = 0;

   339

   340

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

   341

   342

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

   343

		int end = *index_tbl++;

   344

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

   345

			SkipSprites(end);

   346

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

   347

			do {

   348

			#ifdef NDEBUG

   349

				LoadNextSprite(start, file_index);

   350

			#else

   351

				bool b = LoadNextSprite(start, file_index);

   352

				assert(b);

   353

			#endif

   354

			} while (++start <= end);

   355

		}

   356

	}

   357

}

   358

   359

   360

#define S_FREE_MASK 1

   361

   362

static inline MemBlock* NextBlock(MemBlock* block)

   363

{

   364

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

   365

}

   366

   367

static uint32 GetSpriteCacheUsage(void)

   368

{

   369

	size_t tot_size = 0;

   370

	MemBlock* s;

   371

   372

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

   373

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

   374

   375

	return tot_size;

   376

}

   377

   378

   379

void IncreaseSpriteLRU(void)

   380

{

   381

	int i;

   382

   383

	// Increase all LRU values

   384

#if defined(WANT_NEW_LRU)

   385

	if (_sprite_lru_counter > 16384) {

   386

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

   387

   388

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

   389

			if (_sprite_ptr[i] != NULL) {

   390

				if (_sprite_lru_new[i] >= 0) {

   391

					_sprite_lru_new[i] = -1;

   392

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

   393

					_sprite_lru_new[i]--;

   394

				}

   395

			}

   396

		_sprite_lru_counter = 0;

   397

	}

   398

#else

   399

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

   400

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

   401

			_sprite_lru[i]++;

   402

	// Reset the lru counter.

   403

	_sprite_lru_counter = 0;

   404

#endif

   405

   406

	// Compact sprite cache every now and then.

   407

	if (++_compact_cache_counter >= 740) {

   408

		CompactSpriteCache();

   409

		_compact_cache_counter = 0;

   410

	}

   411

}

   412

   413

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

   414

// That is accomplished by moving the cached data.

   415

static void CompactSpriteCache(void)

   416

{

   417

	MemBlock *s;

   418

   419

	DEBUG(spritecache, 2) (

   420

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

   421

	);

   422

   423

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

   424

		if (s->size & S_FREE_MASK) {

   425

			MemBlock* next = NextBlock(s);

   426

			MemBlock temp;

   427

			void** i;

   428

   429

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

   430

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

   431

   432

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

   433

			if (next->size == 0)

   434

				break;

   435

   436

			// Locate the sprite belonging to the next pointer.

   437

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

   438

				assert(i != endof(_sprite_ptr));

   439

			}

   440

   441

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

   442

			// Swap this and the next block

   443

			temp = *s;

   444

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

   445

			s = NextBlock(s);

   446

			*s = temp;

   447

   448

			// Coalesce free blocks

   449

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

   450

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

   451

			}

   452

		} else {

   453

			s = NextBlock(s);

   454

		}

   455

	}

   456

}

   457

   458

static void DeleteEntryFromSpriteCache(void)

   459

{

   460

	int i;

   461

	int best = -1;

   462

	MemBlock* s;

   463

	int cur_lru;

   464

   465

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

   466

   467

#if defined(WANT_NEW_LRU)

   468

	cur_lru = 0xffff;

   469

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

   470

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

   471

			cur_lru = _sprite_lru_new[i];

   472

			best = i;

   473

		}

   474

	}

   475

#else

   476

	{

   477

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   478

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

   479

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

   480

   481

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

   482

		if (_sprite_lru[i] != cur_lru) {

   483

			cur_lru = _sprite_lru[i];

   484

			best = i;

   485

   486

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

   487

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

   488

			cur_lru_cur = _sprite_lru_cur[i];

   489

			cur_lru = _sprite_lru[i];

   490

			best = i;

   491

		}

   492

	}

   493

	}

   494

#endif

   495

   496

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