1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "gfx.h"

     5

#include "spritecache.h"

     6

#include "fileio.h"

     7

#include "newgrf.h"

     8

#include "md5.h"

     9

#include <ctype.h>

    10

    11

#define SPRITECACHE_ID 0xF00F0006

    12

#define SPRITE_CACHE_SIZE 1024*1024

    13

    14

    15

//#define WANT_SPRITESIZES

    16

#define WANT_NEW_LRU

    17

//#define WANT_LOCKED

    18

    19

    20

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

    21

    22

int _skip_sprites = 0;

    23

int _replace_sprites_count[16];

    24

int _replace_sprites_offset[16];

    25

    26

static const char *_cur_grffile;

    27

static int _loading_stage;

    28

static int _skip_specials;

    29

uint16 _custom_sprites_base;

    30

static Sprite _cur_sprite;

    31

    32

    33

static byte *_sprite_ptr[NUM_SPRITES];

    34

static uint16 _sprite_size[NUM_SPRITES];

    35

static uint32 _sprite_file_pos[NUM_SPRITES];

    36

    37

// This one is probably not needed.

    38

#if defined(WANT_LOCKED)

    39

static bool _sprite_locked[NUM_SPRITES];

    40

#endif

    41

    42

#if defined(WANT_NEW_LRU)

    43

static int16 _sprite_lru_new[NUM_SPRITES];

    44

#else

    45

static uint16 _sprite_lru[NUM_SPRITES];

    46

static uint16 _sprite_lru_cur[NUM_SPRITES];

    47

#endif

    48

    49

#ifdef WANT_SPRITESIZES

    50

static int8 _sprite_xoffs[NUM_SPRITES];

    51

static int8 _sprite_yoffs[NUM_SPRITES];

    52

static uint16 _sprite_xsize[NUM_SPRITES];

    53

static uint8 _sprite_ysize[NUM_SPRITES];

    54

#endif

    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[4];     // 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 uint16 * const _landscape_spriteindexes[] = {

    80

	_landscape_spriteindexes_1,

    81

	_landscape_spriteindexes_2,

    82

	_landscape_spriteindexes_3,

    83

};

    84

    85

static const uint16 * 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

   151

{

   152

	uint num = _sprite_size[id];

   153

	byte type;

   155

   156

	FioSeekToFile(_sprite_file_pos[id]);

   157

   158

	type = FioReadByte();

   159

	/* We've decoded special sprites when reading headers. */

   160

	if (type != 0xFF) {

   161

		/* read sprite hdr */

   163

		sprite->info = type;

   164

		sprite->height = FioReadByte();

   165

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

   166

		sprite->width = FioReadWord();

   167

		sprite->x_offs = FioReadWord();

   168

		sprite->y_offs = FioReadWord();

   169

		dest = sprite->data;

   170

		num -= 8;

   173

	}

   174

   175

	if (type & 2) {

   176

		for (; num > 0; --num)

   177

			*dest++ = FioReadByte();

   178

	} else {

   179

		while (num > 0) {

   180

			int8 i = FioReadByte();

   181

   182

			if (i >= 0) {

   183

				num -= i;

   184

				for (; i > 0; --i)

   185

					*dest++ = FioReadByte();

   186

			} else {

   187

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

   188

   189

				i = -(i >> 3);

   190

				num -= i;

   191

   192

				for (; i > 0; --i)

   193

					*dest++ = *rel++;

   194

			}

   195

		}

   196

	}

   197

}

   198

   199

   200

static bool LoadNextSprite(int load_index, byte file_index)

   201

{

   202

	uint16 size;

   203

	uint32 file_pos;

   204

   205

	size = FioReadWord();

   206

	if (size == 0)

   207

		return false;

   208

   209

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

   210

   211

	ReadSpriteHeaderSkipData(size, load_index);

   212

   213

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

   214

		int count = _replace_sprites_count[0];

   215

		int offset = _replace_sprites_offset[0];

   216

   217

		_replace_sprites_offset[0]++;

   218

		_replace_sprites_count[0]--;

   219

   220

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

   221

			load_index = offset;

   222

		} else {

   223

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

   224

					count, offset);

   225

			_replace_sprites_offset[0] = 0;

   226

			_replace_sprites_count[0] = 0;

   227

		}

   228

   229

		if (_replace_sprites_count[0] == 0) {

   230

			int i;

   231

   232

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

   233

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

   234

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

   235

			}

   236

			_replace_sprites_count[i] = 0;

   237

			_replace_sprites_offset[i] = 0;

   238

		}

   239

	}

   240

   241

	_sprite_size[load_index] = size;

   242

	_sprite_file_pos[load_index] = file_pos;

   243

   244

#ifdef WANT_SPRITESIZES

   245

	_sprite_xsize[load_index] = _cur_sprite.width;

   246

	_sprite_ysize[load_index] = _cur_sprite.height;

   247

   248

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   249

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   250

#endif

   251

   252

	_sprite_ptr[load_index] = NULL;

   253

#if defined(WANT_LOCKED)

   254

	_sprite_locked[load_index] = false;

   255

#endif

   256

   257

#if defined(WANT_NEW_LRU)

   258

	_sprite_lru_new[load_index] = 0;

   259

#else

   260

	_sprite_lru[load_index] = 0xFFFF;

   261

	_sprite_lru_cur[load_index] = 0;

   262

#endif

   263

   264

	return true;

   265

}

   266

   267

static void SkipSprites(uint count)

   268

{

   269

	for (; count > 0; --count)

   270

	{

   271

		uint16 size = FioReadWord();

   272

   273

		if (size == 0)

   274

			return;

   275

   276

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   277

	}

   278

}

   279

   280

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

   281

{

   282

	int load_index_org = load_index;

   283

   284

	FioOpenFile(file_index, filename);

   285

   286

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

   287

	 * might contain some special sprites. */

   288

	_skip_specials = 1;

   289

	_skip_sprites = 0;

   290

   291

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

   292

   293

	while (LoadNextSprite(load_index, file_index)) {

   294

		load_index++;

   295

		if (load_index >= NUM_SPRITES) {

   296

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

   297

		}

   298

	}

   299

   300

	return load_index - load_index_org;

   301

}

   302

   303

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

   304

{

   305

	int i;

   306

   307

	FioOpenFile(file_index, filename);

   308

	_cur_grffile = filename;

   309

	_skip_specials = 0;

   310

	_skip_sprites = 0;

   311

   312

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

   313

			filename, load_index);

   314

   315

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

   316

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

   317

	 * neither, apparently. */

   318

	{

   319

		int length;

   320

		byte type;

   321

   322

		length = FioReadWord();

   323

		type = FioReadByte();

   324

   325

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

   326

			FioReadDword();

   327

		} else {

   328

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

   329

		}

   330

	}

   331

   332

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

   333

		if (load_index + i >= NUM_SPRITES)

   334

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

   335

			      load_index + i);

   336

	}

   337

   338

	/* Clean up. */

   339

	_skip_sprites = 0;

   340

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

   341

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

   342

   343

	return i;

   344

}

   345

   346

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

   347

{

   348

	int start;

   349

   350

	FioOpenFile(file_index, filename);

   351

	_skip_specials = 1;

   352

	_skip_sprites = 0;

   353

   354

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

   355

   356

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

   357

		int end = *index_tbl++;

   358

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

   359

			SkipSprites(end);

   360

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

   361

			do {

   362

				bool b = LoadNextSprite(start, file_index);

   363

				assert(b);

   364

			} while (++start <= end);

   365

		}

   366

	}

   367

}

   368

   369

typedef size_t CDECL fread_t(void*, size_t, size_t, FILE*);

   370

   371

static bool HandleCachedSpriteHeaders(const char *filename, bool read)

   372

{

   373

	FILE *f;

   374

	fread_t *proc;

   375

	uint32 hdr;

   376

   377

	if (!_cache_sprites)

   378

		return false;

   379

   380

	if (read) {

   381

		f = fopen(filename, "rb");

   382

		proc = fread;

   383

   384

		if (f == NULL)

   385

			return false;

   386

   387

		proc(&hdr, sizeof(hdr), 1, f);

   388

		if (hdr != SPRITECACHE_ID) {

   389

			fclose(f);

   390

			return false;

   391

		}

   392

	} else {

   393

		f = fopen(filename, "wb");

   394

		proc = (fread_t*) fwrite;

   395

   396

		if (f == NULL)

   397

			return false;

   398

   399

		hdr = SPRITECACHE_ID;

   400

		proc(&hdr, sizeof(hdr), 1, f);

   401

	}

   402

   403

	proc(_sprite_size, 1, sizeof(_sprite_size), f);

   404

	proc(_sprite_file_pos, 1, sizeof(_sprite_file_pos), f);

   405

   406

#if 0

   407

	proc(_sprite_xsize, 1, sizeof(_sprite_xsize), f);

   408

	proc(_sprite_ysize, 1, sizeof(_sprite_ysize), f);

   409

	proc(_sprite_xoffs, 1, sizeof(_sprite_xoffs), f);

   410

	proc(_sprite_yoffs, 1, sizeof(_sprite_yoffs), f);

   411

#endif

   412

   413

#if !defined(WANT_NEW_LRU)

   414

	if (read)

   415

		memset(_sprite_lru, 0xFF, sizeof(_sprite_lru));

   416

#endif

   417

   418

	fclose(f);

   419

	return true;

   420

}

   421

   422

#define S_FREE_MASK 1

   423

   424

static inline MemBlock* NextBlock(MemBlock* block)

   425

{

   426

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

   427

}

   428

   429

static uint32 GetSpriteCacheUsage(void)

   430

{

   431

	size_t tot_size = 0;

   432

	MemBlock* s;

   433

   434

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

   435

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

   436

   437

	return tot_size;

   438

}

   439

   440

   441

void IncreaseSpriteLRU(void)

   442

{

   443

	int i;

   444

   445

	// Increase all LRU values

   446

#if defined(WANT_NEW_LRU)

   447

	if (_sprite_lru_counter > 16384) {

   448

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

   449

   450

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

   451

			if (_sprite_ptr[i] != NULL) {

   452

				if (_sprite_lru_new[i] >= 0) {

   453

					_sprite_lru_new[i] = -1;

   454

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

   455

					_sprite_lru_new[i]--;

   456

				}

   457

			}

   458

		_sprite_lru_counter = 0;

   459

	}

   460

#else

   461

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

   462

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

   463

			_sprite_lru[i]++;

   464

	// Reset the lru counter.

   465

	_sprite_lru_counter = 0;

   466

#endif

   467

   468

	// Compact sprite cache every now and then.

   469

	if (++_compact_cache_counter >= 740) {

   470

		CompactSpriteCache();

   471

		_compact_cache_counter = 0;

   472

	}

   473

}

   474

   475

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

   476

// That is accomplished by moving the cached data.

   477

static void CompactSpriteCache(void)

   478

{

   479

	MemBlock *s;

   480

   481

	DEBUG(spritecache, 2) (

   482

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

   483

	);

   484

   485

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

   486

		if (s->size & S_FREE_MASK) {

   487

			MemBlock* next = NextBlock(s);

   488

			MemBlock temp;

   489

			byte** i;

   490

   491

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

   492

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

   493

   494

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

   495

			if (next->size == 0)

   496

				break;

   497

   498

			// Locate the sprite belonging to the next pointer.

   499

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

   500

				assert(i != endof(_sprite_ptr));

   501

			}

   502

   503

			#ifdef WANT_LOCKED

   504