1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "gfx.h"

     5

#include "spritecache.h"

     6

#include "table/sprites.h"

     7

#include "fileio.h"

     8

#include "newgrf.h"

     9

#include "md5.h"

    10

#include <ctype.h>

    11

    12

#define SPRITECACHE_ID 0xF00F0006

    13

#define SPRITE_CACHE_SIZE 1024*1024

    14

    15

    16

//#define WANT_SPRITESIZES

    17

#define WANT_NEW_LRU

    18

//#define WANT_LOCKED

    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 byte *_sprite_ptr[NUM_SPRITES];

    35

static uint16 _sprite_size[NUM_SPRITES];

    36

static uint32 _sprite_file_pos[NUM_SPRITES];

    37

    38

// This one is probably not needed.

    39

#if defined(WANT_LOCKED)

    40

static bool _sprite_locked[NUM_SPRITES];

    41

#endif

    42

    43

#if defined(WANT_NEW_LRU)

    44

static int16 _sprite_lru_new[NUM_SPRITES];

    45

#else

    46

static uint16 _sprite_lru[NUM_SPRITES];

    47

static uint16 _sprite_lru_cur[NUM_SPRITES];

    48

#endif

    49

    50

#ifdef WANT_SPRITESIZES

    51

static int8 _sprite_xoffs[NUM_SPRITES];

    52

static int8 _sprite_yoffs[NUM_SPRITES];

    53

static uint16 _sprite_xsize[NUM_SPRITES];

    54

static uint8 _sprite_ysize[NUM_SPRITES];

    55

#endif

    56

    57

typedef struct MemBlock {

    58

	uint32 size;

    59

	byte data[VARARRAY_SIZE];

    60

} MemBlock;

    61

    62

static uint _sprite_lru_counter;

    63

static MemBlock *_spritecache_ptr;

    64

static uint32 _spritecache_size;

    65

static int _compact_cache_counter;

    66

    67

typedef struct MD5File {

    68

	const char * const filename;     // filename

    69

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

    70

} MD5File;

    71

    72

typedef struct FileList {

    73

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

    74

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

    75

} FileList;

    76

    77

#include "table/files.h"

    78

#include "table/landscape_sprite.h"

    79

    80

static const uint16 * const _landscape_spriteindexes[] = {

    81

	_landscape_spriteindexes_1,

    82

	_landscape_spriteindexes_2,

    83

	_landscape_spriteindexes_3,

    84

};

    85

    86

static const uint16 * const _slopes_spriteindexes[] = {

    87

	_slopes_spriteindexes_0,

    88

	_slopes_spriteindexes_1,

    89

	_slopes_spriteindexes_2,

    90

	_slopes_spriteindexes_3,

    91

};

    92

    93

static void CompactSpriteCache(void);

    94

    95

static void ReadSpriteHeaderSkipData(int num, int load_index)

    96

{

    97

	byte type;

    98

	int deaf = 0;

    99

   100

	if (_skip_sprites) {

   101

		if (_skip_sprites > 0)

   102

			_skip_sprites--;

   103

		deaf = 1;

   104

	}

   105

   106

	type = FioReadByte();

   107

	_cur_sprite.info = type;

   108

	if (type == 0xFF) {

   109

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

   110

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

   111

		 * because if no special sprite referencing to them is

   112

		 * processed, they themselves are never referenced and loaded

   113

		 * on their own. */

   114

		if (_skip_specials || deaf) {

   115

			FioSkipBytes(num);

   116

		} else {

   117

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   118

		}

   119

		return;

   120

	}

   121

   122

#ifdef WANT_SPRITESIZES

   123

	_cur_sprite.height = FioReadByte();

   124

	_cur_sprite.width = FioReadWord();

   125

	_cur_sprite.x_offs = FioReadWord();

   126

	_cur_sprite.y_offs = FioReadWord();

   127

#else

   128

	FioSkipBytes(7);

   129

#endif

   130

	num -= 8;

   131

	if (num == 0)

   132

		return;

   133

   134

	if (type & 2) {

   135

		FioSkipBytes(num);

   136

	} else {

   137

		while (num > 0) {

   138

			int8 i = FioReadByte();

   139

			if (i >= 0) {

   140

				num -= i;

   141

				FioSkipBytes(i);

   142

			} else {

   143

				i = -(i >> 3);

   144

				num -= i;

   145

				FioReadByte();

   146

			}

   147

		}

   148

	}

   149

}

   150

   151

static void ReadSprite(SpriteID id, void *buffer)

   152

{

   153

	uint num = _sprite_size[id];

   154

	byte type;

   155

	byte* dest;

   156

   165

	FioSeekToFile(_sprite_file_pos[id]);

   166

   167

	type = FioReadByte();

   168

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

   169

	if (type != 0xFF) {

   170

		/* read sprite hdr */

   171

		Sprite* sprite = buffer;

   172

		sprite->info = type;

   173

		sprite->height = FioReadByte();

   174

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

   175

		sprite->width = FioReadWord();

   176

		sprite->x_offs = FioReadWord();

   177

		sprite->y_offs = FioReadWord();

   178

		dest = sprite->data;

   179

		num -= 8;

   180

	} else {

   181

		dest = buffer;

   182

	}

   183

   184

	if (type & 2) {

   185

		for (; num > 0; --num)

   186

			*dest++ = FioReadByte();

   187

	} else {

   188

		while (num > 0) {

   189

			int8 i = FioReadByte();

   190

   191

			if (i >= 0) {

   192

				num -= i;

   193

				for (; i > 0; --i)

   194

					*dest++ = FioReadByte();

   195

			} else {

   196

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

   197

   198

				i = -(i >> 3);

   199

				num -= i;

   200

   201

				for (; i > 0; --i)

   202

					*dest++ = *rel++;

   203

			}

   204

		}

   205

	}

   206

}

   207

   208

   209

static bool LoadNextSprite(int load_index, byte file_index)

   210

{

   211

	uint16 size;

   212

	uint32 file_pos;

   213

   214

	size = FioReadWord();

   215

	if (size == 0)

   216

		return false;

   217

   218

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

   219

   220

	ReadSpriteHeaderSkipData(size, load_index);

   221

   222

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

   223

		int count = _replace_sprites_count[0];

   224

		int offset = _replace_sprites_offset[0];

   225

   226

		_replace_sprites_offset[0]++;

   227

		_replace_sprites_count[0]--;

   228

   229

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

   230

			load_index = offset;

   231

		} else {

   232

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

   233

					count, offset);

   234

			_replace_sprites_offset[0] = 0;

   235

			_replace_sprites_count[0] = 0;

   236

		}

   237

   238

		if (_replace_sprites_count[0] == 0) {

   239

			int i;

   240

   241

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

   242

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

   243

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

   244

			}

   245

			_replace_sprites_count[i] = 0;

   246

			_replace_sprites_offset[i] = 0;

   247

		}

   248

	}

   249

   250

	_sprite_size[load_index] = size;

   251

	_sprite_file_pos[load_index] = file_pos;

   252

   253

#ifdef WANT_SPRITESIZES

   254

	_sprite_xsize[load_index] = _cur_sprite.width;

   255

	_sprite_ysize[load_index] = _cur_sprite.height;

   256

   257

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   258

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   259

#endif

   260

   261

	_sprite_ptr[load_index] = NULL;

   262

#if defined(WANT_LOCKED)

   263

	_sprite_locked[load_index] = false;

   264

#endif

   265

   266

#if defined(WANT_NEW_LRU)

   267

	_sprite_lru_new[load_index] = 0;

   268

#else

   269

	_sprite_lru[load_index] = 0xFFFF;

   270

	_sprite_lru_cur[load_index] = 0;

   271

#endif

   272

   273

	return true;

   274

}

   275

   276

static void SkipSprites(uint count)

   277

{

   278

	for (; count > 0; --count)

   279

	{

   280

		uint16 size = FioReadWord();

   281

   282

		if (size == 0)

   283

			return;

   284

   285

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   286

	}

   287

}

   288

   289

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

   290

{

   291

	int load_index_org = load_index;

   292

   293

	FioOpenFile(file_index, filename);

   294

   295

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

   296

	 * might contain some special sprites. */

   297

	_skip_specials = 1;

   298

	_skip_sprites = 0;

   299

   300

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

   301

   302

	while (LoadNextSprite(load_index, file_index)) {

   303

		load_index++;

   304

		if (load_index >= NUM_SPRITES) {

   305

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

   306

		}

   307

	}

   308

   309

	return load_index - load_index_org;

   310

}

   311

   312

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

   313

{

   314

	int i;

   315

   316

	FioOpenFile(file_index, filename);

   317

	_cur_grffile = filename;

   318

	_skip_specials = 0;

   319

	_skip_sprites = 0;

   320

   321

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

   322

			filename, load_index);

   323

   324

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

   325

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

   326

	 * neither, apparently. */

   327

	{

   328

		int length;

   329

		byte type;

   330

   331

		length = FioReadWord();

   332

		type = FioReadByte();

   333

   334

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

   335

			FioReadDword();

   336

		} else {

   337

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

   338

		}

   339

	}

   340

   341

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

   342

		if (load_index + i >= NUM_SPRITES)

   343

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

   344

			      load_index + i);

   345

	}

   346

   347

	/* Clean up. */

   348

	_skip_sprites = 0;

   349

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

   350

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

   351

   352

	return i;

   353

}

   354

   355

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

   356

{

   357

	int start;

   358

   359

	FioOpenFile(file_index, filename);

   360

	_skip_specials = 1;

   361

	_skip_sprites = 0;

   362

   363

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

   364

   365

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

   366

		int end = *index_tbl++;

   367

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

   368

			SkipSprites(end);

   369

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

   370

			do {

   371

				bool b = LoadNextSprite(start, file_index);

   372

				assert(b);

   373

			} while (++start <= end);

   374

		}

   375

	}

   376

}

   377

   378

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

   379

   380

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

   381

{

   382

	FILE *f;

   383

	fread_t *proc;

   384

	uint32 hdr;

   385

   386

	if (!_cache_sprites)

   387

		return false;

   388

   389

	if (read) {

   390

		f = fopen(filename, "rb");

   391

		proc = fread;

   392

   393

		if (f == NULL)

   394

			return false;

   395

   396

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

   397

		if (hdr != SPRITECACHE_ID) {

   398

			fclose(f);

   399

			return false;

   400

		}

   401

	} else {

   402

		f = fopen(filename, "wb");

   403

		proc = (fread_t*) fwrite;

   404

   405

		if (f == NULL)

   406

			return false;

   407

   408

		hdr = SPRITECACHE_ID;

   409

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

   410

	}

   411

   412

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

   413

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

   414

   415

#if 0

   416

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

   417

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

   418

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

   419

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

   420

#endif

   421

   422

#if !defined(WANT_NEW_LRU)

   423

	if (read)

   424

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

   425

#endif

   426

   427

	fclose(f);

   428

	return true;

   429

}

   430

   431

#define S_FREE_MASK 1

   432

   433

static inline MemBlock* NextBlock(MemBlock* block)

   434

{

   435

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

   436

}

   437

   438

static uint32 GetSpriteCacheUsage(void)

   439

{

   440

	size_t tot_size = 0;

   441

	MemBlock* s;

   442

   443

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

   444

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

   445

   446

	return tot_size;

   447

}

   448

   449

   450

void IncreaseSpriteLRU(void)

   451

{

   452

	int i;

   453

   454

	// Increase all LRU values

   455

#if defined(WANT_NEW_LRU)

   456

	if (_sprite_lru_counter > 16384) {

   457

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

   458

   459

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

   460

			if (_sprite_ptr[i] != NULL) {

   461

				if (_sprite_lru_new[i] >= 0) {

   462

					_sprite_lru_new[i] = -1;

   463

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

   464

					_sprite_lru_new[i]--;

   465

				}

   466

			}

   467

		_sprite_lru_counter = 0;

   468

	}

   469

#else

   470

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

   471

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

   472

			_sprite_lru[i]++;

   473

	// Reset the lru counter.

   474

	_sprite_lru_counter = 0;

   475

#endif

   476

   477

	// Compact sprite cache every now and then.

   478

	if (++_compact_cache_counter >= 740) {

   479

		CompactSpriteCache();

   480

		_compact_cache_counter = 0;

   481

	}

   482

}

   483

   484

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

   485

// That is accomplished by moving the cached data.

   486

static void CompactSpriteCache(void)

   487

{

   488

	MemBlock *s;

   489

   490

	DEBUG(spritecache, 2) (

   491

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

   492

	);

   493

   494

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

   495

		if (s->size & S_FREE_MASK) {

   496

			MemBlock* next = NextBlock(s);

   497

			MemBlock temp;

   498

			byte** i;

   499

   500

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

   501

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

   502

   503

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