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

    19

//#define WANT_SPRITESIZES

    20

#define WANT_NEW_LRU

    21

    22

    23

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

    24

    25

int _skip_sprites = 0;

    26

int _replace_sprites_count[16];

    27

int _replace_sprites_offset[16];

    28

    29

static const char *_cur_grffile;

    30

static int _loading_stage;

    31

static int _skip_specials;

    32

uint16 _custom_sprites_base;

    33

static Sprite _cur_sprite;

    34

    35

    36

static void* _sprite_ptr[MAX_SPRITES];

    37

static uint16 _sprite_size[MAX_SPRITES];

    38

static uint32 _sprite_file_pos[MAX_SPRITES];

    39

    40

#if defined(WANT_NEW_LRU)

    41

static int16 _sprite_lru_new[MAX_SPRITES];

    42

#else

    43

static uint16 _sprite_lru[MAX_SPRITES];

    44

static uint16 _sprite_lru_cur[MAX_SPRITES];

    45

#endif

    46

    47

#ifdef WANT_SPRITESIZES

    48

static int8 _sprite_xoffs[MAX_SPRITES];

    49

static int8 _sprite_yoffs[MAX_SPRITES];

    50

static uint16 _sprite_xsize[MAX_SPRITES];

    51

static uint8 _sprite_ysize[MAX_SPRITES];

    52

#endif

    53

    54

bool _cache_sprites;

    55

    56

typedef struct MemBlock {

    57

	uint32 size;

    58

	byte data[VARARRAY_SIZE];

    59

} MemBlock;

    60

    61

static uint _sprite_lru_counter;

    62

static MemBlock *_spritecache_ptr;

    63

static uint32 _spritecache_size;

    64

static int _compact_cache_counter;

    65

    66

typedef struct MD5File {

    67

	const char * const filename;     // filename

    68

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

    69

} MD5File;

    70

    71

typedef struct FileList {

    72

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

    73

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

    74

} FileList;

    75

    76

#include "table/files.h"

    77

#include "table/landscape_sprite.h"

    78

    79

static const SpriteID * const _landscape_spriteindexes[] = {

    80

	_landscape_spriteindexes_1,

    81

	_landscape_spriteindexes_2,

    82

	_landscape_spriteindexes_3,

    83

};

    84

    85

static const SpriteID * const _slopes_spriteindexes[] = {

    86

	_slopes_spriteindexes_0,

    87

	_slopes_spriteindexes_1,

    88

	_slopes_spriteindexes_2,

    89

	_slopes_spriteindexes_3,

    90

};

    91

    92

static void CompactSpriteCache(void);

    93

    94

static void ReadSpriteHeaderSkipData(int num, int load_index)

    95

{

    96

	byte type;

    97

	int deaf = 0;

    98

    99

	if (_skip_sprites) {

   100

		if (_skip_sprites > 0)

   101

			_skip_sprites--;

   102

		deaf = 1;

   103

	}

   104

   105

	type = FioReadByte();

   106

	_cur_sprite.info = type;

   107

	if (type == 0xFF) {

   108

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

   109

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

   110

		 * because if no special sprite referencing to them is

   111

		 * processed, they themselves are never referenced and loaded

   112

		 * on their own. */

   113

		if (_skip_specials || deaf) {

   114

			FioSkipBytes(num);

   115

		} else {

   116

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   117

		}

   118

		return;

   119

	}

   120

   121

#ifdef WANT_SPRITESIZES

   122

	_cur_sprite.height = FioReadByte();

   123

	_cur_sprite.width = FioReadWord();

   124

	_cur_sprite.x_offs = FioReadWord();

   125

	_cur_sprite.y_offs = FioReadWord();

   126

#else

   127

	FioSkipBytes(7);

   128

#endif

   129

	num -= 8;

   130

	if (num == 0)

   131

		return;

   132

   133

	if (type & 2) {

   134

		FioSkipBytes(num);

   135

	} else {

   136

		while (num > 0) {

   137

			int8 i = FioReadByte();

   138

			if (i >= 0) {

   139

				num -= i;

   140

				FioSkipBytes(i);

   141

			} else {

   142

				i = -(i >> 3);

   143

				num -= i;

   144

				FioReadByte();

   145

			}

   146

		}

   147

	}

   148

}

   149

   150

static void* AllocSprite(size_t);

   151

   152

static void* ReadSprite(SpriteID id)

   153

{

   154

	uint num = _sprite_size[id];

   155

	byte type;

   156

   157

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

   158

   159

	if (_sprite_file_pos[id] == 0) {

   160

		error(

   161

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

   162

			"Probable cause: Wrong/missing NewGRFs",

   163

			id

   164

		);

   165

	}

   166

   167

	FioSeekToFile(_sprite_file_pos[id]);

   168

   169

	type = FioReadByte();

   170

	if (type == 0xFF) {

   171

		byte* dest = AllocSprite(num);

   172

   173

		_sprite_ptr[id] = dest;

   174

		FioReadBlock(dest, num);

   175

   176

		return dest;

   177

	} else {

   178

		uint height = FioReadByte();

   179

		uint width  = FioReadWord();

   180

		Sprite* sprite;

   181

		byte* dest;

   182

   183

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

   184

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

   185

		_sprite_ptr[id] = sprite;

   186

		sprite->info   = type;

   187

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

   188

		sprite->width  = width;

   189

		sprite->x_offs = FioReadWord();

   190

		sprite->y_offs = FioReadWord();

   191

   192

		dest = sprite->data;

   193

		while (num > 0) {

   194

			int8 i = FioReadByte();

   195

   196

			if (i >= 0) {

   197

				num -= i;

   198

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

   199

			} else {

   200

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

   201

   202

				i = -(i >> 3);

   203

				num -= i;

   204

   205

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

   206

			}

   207

		}

   208

   209

		return sprite;

   210

	}

   211

}

   212

   213

   214

static bool LoadNextSprite(int load_index, byte file_index)

   215

{

   216

	uint16 size;

   217

	uint32 file_pos;

   218

   219

	size = FioReadWord();

   220

	if (size == 0)

   221

		return false;

   222

   223

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

   224

   225

	ReadSpriteHeaderSkipData(size, load_index);

   226

   227

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

   228

		int count = _replace_sprites_count[0];

   229

		int offset = _replace_sprites_offset[0];

   230

   231

		_replace_sprites_offset[0]++;

   232

		_replace_sprites_count[0]--;

   233

   234

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

   235

			load_index = offset;

   236

		} else {

   237

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

   238

					count, offset);

   239

			_replace_sprites_offset[0] = 0;

   240

			_replace_sprites_count[0] = 0;

   241

		}

   242

   243

		if (_replace_sprites_count[0] == 0) {

   244

			int i;

   245

   246

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

   247

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

   248

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

   249

			}

   250

			_replace_sprites_count[i] = 0;

   251

			_replace_sprites_offset[i] = 0;

   252

		}

   253

	}

   254

   255

	_sprite_size[load_index] = size;

   256

	_sprite_file_pos[load_index] = file_pos;

   257

   258

#ifdef WANT_SPRITESIZES

   259

	_sprite_xsize[load_index] = _cur_sprite.width;

   260

	_sprite_ysize[load_index] = _cur_sprite.height;

   261

   262

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   263

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   264

#endif

   265

   266

	_sprite_ptr[load_index] = NULL;

   267

   268

#if defined(WANT_NEW_LRU)

   269

	_sprite_lru_new[load_index] = 0;

   270

#else

   271

	_sprite_lru[load_index] = 0xFFFF;

   272

	_sprite_lru_cur[load_index] = 0;

   273

#endif

   274

   275

	return true;

   276

}

   277

   278

static void SkipSprites(uint count)

   279

{

   280

	for (; count > 0; --count)

   281

	{

   282

		uint16 size = FioReadWord();

   283

   284

		if (size == 0)

   285

			return;

   286

   287

		ReadSpriteHeaderSkipData(size, MAX_SPRITES - 1);

   288

	}

   289

}

   290

   291

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

   292

{

   293

	int load_index_org = load_index;

   294

   295

	FioOpenFile(file_index, filename);

   296

   297

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

   298

	 * might contain some special sprites. */

   299

	_skip_specials = 1;

   300

	_skip_sprites = 0;

   301

   302

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

   303

   304

	while (LoadNextSprite(load_index, file_index)) {

   305

		load_index++;

   306

		if (load_index >= MAX_SPRITES) {

   307

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

   308

		}

   309

	}

   310

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

   311

   312

	return load_index - load_index_org;

   313

}

   314

   315

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

   316

{

   317

	int i;

   318

   319

	FioOpenFile(file_index, filename);

   320

	_cur_grffile = filename;

   321

	_skip_specials = 0;

   322

	_skip_sprites = 0;

   323

   324

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

   325

			filename, load_index);

   326

   327

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

   328

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

   329

	 * neither, apparently. */

   330

	{

   331

		int length;

   332

		byte type;

   333

   334

		length = FioReadWord();

   335

		type = FioReadByte();

   336

   337

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

   338

			FioReadDword();

   339

		} else {

   340

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

   341

		}

   342

	}

   343

   344

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

   345

		if (load_index + i >= MAX_SPRITES)

   346

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

   347

			      load_index + i);

   348

	}

   349

   350

	/* Clean up. */

   351

	_skip_sprites = 0;

   352

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

   353

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

   354

   355

	return i;

   356

}

   357

   358

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

   359

{

   360

	int start;

   361

   362

	FioOpenFile(file_index, filename);

   363

	_skip_specials = 1;

   364

	_skip_sprites = 0;

   365

   366

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

   367

   368

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

   369

		int end = *index_tbl++;

   370

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

   371

			SkipSprites(end);

   372

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

   373

			do {

   374

			#ifdef NDEBUG

   375

				LoadNextSprite(start, file_index);

   376

			#else

   377

				bool b = LoadNextSprite(start, file_index);

   378

				assert(b);

   379

			#endif

   380

			} while (++start <= end);

   381

		}

   382

	}

   383

}

   384

   385

   386

#define S_FREE_MASK 1

   387

   388

static inline MemBlock* NextBlock(MemBlock* block)

   389

{

   390

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

   391

}

   392

   393

static uint32 GetSpriteCacheUsage(void)

   394

{

   395

	size_t tot_size = 0;

   396

	MemBlock* s;

   397

   398

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

   399

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

   400

   401

	return tot_size;

   402

}

   403

   404

   405

void IncreaseSpriteLRU(void)

   406

{

   407

	int i;

   408

   409

	// Increase all LRU values

   410

#if defined(WANT_NEW_LRU)

   411

	if (_sprite_lru_counter > 16384) {

   412

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

   413

   414

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

   415

			if (_sprite_ptr[i] != NULL) {

   416

				if (_sprite_lru_new[i] >= 0) {

   417

					_sprite_lru_new[i] = -1;

   418

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

   419

					_sprite_lru_new[i]--;

   420

				}

   421

			}

   422

		_sprite_lru_counter = 0;

   423

	}

   424

#else

   425

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

   426

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

   427

			_sprite_lru[i]++;

   428

	// Reset the lru counter.

   429

	_sprite_lru_counter = 0;

   430

#endif

   431

   432

	// Compact sprite cache every now and then.

   433

	if (++_compact_cache_counter >= 740) {

   434

		CompactSpriteCache();

   435

		_compact_cache_counter = 0;

   436

	}

   437

}

   438

   439

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

   440

// That is accomplished by moving the cached data.

   441

static void CompactSpriteCache(void)

   442

{

   443

	MemBlock *s;

   444

   445

	DEBUG(spritecache, 2) (

   446

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

   447

	);

   448

   449

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

   450

		if (s->size & S_FREE_MASK) {

   451

			MemBlock* next = NextBlock(s);

   452

			MemBlock temp;

   453

			void** i;

   454

   455

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

   456

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

   457

   458

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

   459

			if (next->size == 0)

   460

				break;

   461

   462

			// Locate the sprite belonging to the next pointer.

   463

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

   464

				assert(i != endof(_sprite_ptr));

   465

			}

   466

   467

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

   468

			// Swap this and the next block

   469

			temp = *s;

   470

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

   471

			s = NextBlock(s);

   472

			*s = temp;

   473

   474

			// Coalesce free blocks

   475

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

   476

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

   477

			}

   478

		} else {

   479

			s = NextBlock(s);

   480

		}

   481

	}

   482

}

   483

   484

static void DeleteEntryFromSpriteCache(void)

   485

{

   486

	int i;

   487

	int best = -1;

   488

	MemBlock* s;

   489

	int cur_lru;

   490

   491

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

   492

   493

#if defined(WANT_NEW_LRU)

   494

	cur_lru = 0xffff;

   495

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

   496

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