1

#include "stdafx.h"

     2

#include "openttd.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 "variables.h"

    11

#include <ctype.h>

    12

    13

#define SPRITECACHE_ID 0xF00F0006

    14

#define SPRITE_CACHE_SIZE 1024*1024

    15

    16

    17

//#define WANT_SPRITESIZES

    18

#define WANT_NEW_LRU

    19

//#define WANT_LOCKED

    20

    21

    22

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

    23

    24

int _skip_sprites = 0;

    25

int _replace_sprites_count[16];

    26

int _replace_sprites_offset[16];

    27

    28

static const char *_cur_grffile;

    29

static int _loading_stage;

    30

static int _skip_specials;

    31

uint16 _custom_sprites_base;

    32

static Sprite _cur_sprite;

    33

    34

    35

static void* _sprite_ptr[NUM_SPRITES];

    36

static uint16 _sprite_size[NUM_SPRITES];

    37

static uint32 _sprite_file_pos[NUM_SPRITES];

    38

    39

// This one is probably not needed.

    40

#if defined(WANT_LOCKED)

    41

static bool _sprite_locked[NUM_SPRITES];

    42

#endif

    43

    44

#if defined(WANT_NEW_LRU)

    45

static int16 _sprite_lru_new[NUM_SPRITES];

    46

#else

    47

static uint16 _sprite_lru[NUM_SPRITES];

    48

static uint16 _sprite_lru_cur[NUM_SPRITES];

    49

#endif

    50

    51

#ifdef WANT_SPRITESIZES

    52

static int8 _sprite_xoffs[NUM_SPRITES];

    53

static int8 _sprite_yoffs[NUM_SPRITES];

    54

static uint16 _sprite_xsize[NUM_SPRITES];

    55

static uint8 _sprite_ysize[NUM_SPRITES];

    56

#endif

    57

    58

bool _cache_sprites;

    59

    60

typedef struct MemBlock {

    61

	uint32 size;

    62

	byte data[VARARRAY_SIZE];

    63

} MemBlock;

    64

    65

static uint _sprite_lru_counter;

    66

static MemBlock *_spritecache_ptr;

    67

static uint32 _spritecache_size;

    68

static int _compact_cache_counter;

    69

    70

typedef struct MD5File {

    71

	const char * const filename;     // filename

    72

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

    73

} MD5File;

    74

    75

typedef struct FileList {

    76

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

    77

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

    78

} FileList;

    79

    80

#include "table/files.h"

    81

#include "table/landscape_sprite.h"

    82

    83

static const uint16 * const _landscape_spriteindexes[] = {

    84

	_landscape_spriteindexes_1,

    85

	_landscape_spriteindexes_2,

    86

	_landscape_spriteindexes_3,

    87

};

    88

    89

static const uint16 * const _slopes_spriteindexes[] = {

    90

	_slopes_spriteindexes_0,

    91

	_slopes_spriteindexes_1,

    92

	_slopes_spriteindexes_2,

    93

	_slopes_spriteindexes_3,

    94

};

    95

    96

static void CompactSpriteCache(void);

    97

    98

static void ReadSpriteHeaderSkipData(int num, int load_index)

    99

{

   100

	byte type;

   101

	int deaf = 0;

   102

   103

	if (_skip_sprites) {

   104

		if (_skip_sprites > 0)

   105

			_skip_sprites--;

   106

		deaf = 1;

   107

	}

   108

   109

	type = FioReadByte();

   110

	_cur_sprite.info = type;

   111

	if (type == 0xFF) {

   112

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

   113

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

   114

		 * because if no special sprite referencing to them is

   115

		 * processed, they themselves are never referenced and loaded

   116

		 * on their own. */

   117

		if (_skip_specials || deaf) {

   118

			FioSkipBytes(num);

   119

		} else {

   120

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   121

		}

   122

		return;

   123

	}

   124

   125

#ifdef WANT_SPRITESIZES

   126

	_cur_sprite.height = FioReadByte();

   127

	_cur_sprite.width = FioReadWord();

   128

	_cur_sprite.x_offs = FioReadWord();

   129

	_cur_sprite.y_offs = FioReadWord();

   130

#else

   131

	FioSkipBytes(7);

   132

#endif

   133

	num -= 8;

   134

	if (num == 0)

   135

		return;

   136

   137

	if (type & 2) {

   138

		FioSkipBytes(num);

   139

	} else {

   140

		while (num > 0) {

   141

			int8 i = FioReadByte();

   142

			if (i >= 0) {

   143

				num -= i;

   144

				FioSkipBytes(i);

   145

			} else {

   146

				i = -(i >> 3);

   147

				num -= i;

   148

				FioReadByte();

   149

			}

   150

		}

   151

	}

   152

}

   153

   154

static void* AllocSprite(size_t);

   155

   156

static void* ReadSprite(SpriteID id)

   157

{

   158

	uint num = _sprite_size[id];

   159

	byte type;

   160

   161

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

   162

   163

	if (_sprite_file_pos[id] == 0) {

   164

		error(

   165

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

   166

			"Probable cause: Wrong/missing NewGRFs",

   167

			id

   168

		);

   169

	}

   170

   171

	FioSeekToFile(_sprite_file_pos[id]);

   172

   173

	type = FioReadByte();

   174

	if (type == 0xFF) {

   175

		byte* dest = AllocSprite(num);

   176

   177

		_sprite_ptr[id] = dest;

   178

		FioReadBlock(dest, num);

   179

   180

		return dest;

   181

	} else {

   182

		uint height = FioReadByte();

   183

		uint width  = FioReadWord();

   184

		Sprite* sprite;

   185

		byte* dest;

   186

   187

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

   188

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

   189

		_sprite_ptr[id] = sprite;

   190

		sprite->info   = type;

   191

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

   192

		sprite->width  = width;

   193

		sprite->x_offs = FioReadWord();

   194

		sprite->y_offs = FioReadWord();

   195

   196

		dest = sprite->data;

   197

		while (num > 0) {

   198

			int8 i = FioReadByte();

   199

   200

			if (i >= 0) {

   201

				num -= i;

   202

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

   203

			} else {

   204

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

   205

   206

				i = -(i >> 3);

   207

				num -= i;

   208

   209

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

   210

			}

   211

		}

   212

   213

		return sprite;

   214

	}

   215

}

   216

   217

   218

static bool LoadNextSprite(int load_index, byte file_index)

   219

{

   220

	uint16 size;

   221

	uint32 file_pos;

   222

   223

	size = FioReadWord();

   224

	if (size == 0)

   225

		return false;

   226

   227

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

   228

   229

	ReadSpriteHeaderSkipData(size, load_index);

   230

   231

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

   232

		int count = _replace_sprites_count[0];

   233

		int offset = _replace_sprites_offset[0];

   234

   235

		_replace_sprites_offset[0]++;

   236

		_replace_sprites_count[0]--;

   237

   238

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

   239

			load_index = offset;

   240

		} else {

   241

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

   242

					count, offset);

   243

			_replace_sprites_offset[0] = 0;

   244

			_replace_sprites_count[0] = 0;

   245

		}

   246

   247

		if (_replace_sprites_count[0] == 0) {

   248

			int i;

   249

   250

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

   251

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

   252

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

   253

			}

   254

			_replace_sprites_count[i] = 0;

   255

			_replace_sprites_offset[i] = 0;

   256

		}

   257

	}

   258

   259

	_sprite_size[load_index] = size;

   260

	_sprite_file_pos[load_index] = file_pos;

   261

   262

#ifdef WANT_SPRITESIZES

   263

	_sprite_xsize[load_index] = _cur_sprite.width;

   264

	_sprite_ysize[load_index] = _cur_sprite.height;

   265

   266

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   267

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   268

#endif

   269

   270

	_sprite_ptr[load_index] = NULL;

   271

#if defined(WANT_LOCKED)

   272

	_sprite_locked[load_index] = false;

   273

#endif

   274

   275

#if defined(WANT_NEW_LRU)

   276

	_sprite_lru_new[load_index] = 0;

   277

#else

   278

	_sprite_lru[load_index] = 0xFFFF;

   279

	_sprite_lru_cur[load_index] = 0;

   280

#endif

   281

   282

	return true;

   283

}

   284

   285

static void SkipSprites(uint count)

   286

{

   287

	for (; count > 0; --count)

   288

	{

   289

		uint16 size = FioReadWord();

   290

   291

		if (size == 0)

   292

			return;

   293

   294

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   295

	}

   296

}

   297

   298

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

   299

{

   300

	int load_index_org = load_index;

   301

   302

	FioOpenFile(file_index, filename);

   303

   304

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

   305

	 * might contain some special sprites. */

   306

	_skip_specials = 1;

   307

	_skip_sprites = 0;

   308

   309

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

   310

   311

	while (LoadNextSprite(load_index, file_index)) {

   312

		load_index++;

   313

		if (load_index >= NUM_SPRITES) {

   314

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

   315

		}

   316

	}

   317

   318

	return load_index - load_index_org;

   319

}

   320

   321

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

   322

{

   323

	int i;

   324

   325

	FioOpenFile(file_index, filename);

   326

	_cur_grffile = filename;

   327

	_skip_specials = 0;

   328

	_skip_sprites = 0;

   329

   330

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

   331

			filename, load_index);

   332

   333

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

   334

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

   335

	 * neither, apparently. */

   336

	{

   337

		int length;

   338

		byte type;

   339

   340

		length = FioReadWord();

   341

		type = FioReadByte();

   342

   343

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

   344

			FioReadDword();

   345

		} else {

   346

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

   347

		}

   348

	}

   349

   350

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

   351

		if (load_index + i >= NUM_SPRITES)

   352

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

   353

			      load_index + i);

   354

	}

   355

   356

	/* Clean up. */

   357

	_skip_sprites = 0;

   358

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

   359

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

   360

   361

	return i;

   362

}

   363

   364

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

   365

{

   366

	int start;

   367

   368

	FioOpenFile(file_index, filename);

   369

	_skip_specials = 1;

   370

	_skip_sprites = 0;

   371

   372

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

   373

   374

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

   375

		int end = *index_tbl++;

   376

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

   377

			SkipSprites(end);

   378

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

   379

			do {

   380

			#ifdef NDEBUG

   381

				LoadNextSprite(start, file_index);

   382

			#else

   383

				bool b = LoadNextSprite(start, file_index);

   384

				assert(b);

   385

			#endif

   386

			} while (++start <= end);

   387

		}

   388

	}

   389

}

   390

   391

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

   392

   393

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

   394

{

   395

	FILE *f;

   396

	fread_t *proc;

   397

	uint32 hdr;

   398

   399

	if (!_cache_sprites)

   400

		return false;

   401

   402

	if (read) {

   403

		f = fopen(filename, "rb");

   404

		proc = fread;

   405

   406

		if (f == NULL)

   407

			return false;

   408

   409

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

   410

		if (hdr != SPRITECACHE_ID) {

   411

			fclose(f);

   412

			return false;

   413

		}

   414

	} else {

   415

		f = fopen(filename, "wb");

   416

		proc = (fread_t*) fwrite;

   417

   418

		if (f == NULL)

   419

			return false;

   420

   421

		hdr = SPRITECACHE_ID;

   422

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

   423

	}

   424

   425

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

   426

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

   427

   428

#if 0

   429

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

   430

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

   431

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

   432

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

   433

#endif

   434

   435

#if !defined(WANT_NEW_LRU)

   436

	if (read)

   437

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

   438

#endif

   439

   440

	fclose(f);

   441

	return true;

   442

}

   443

   444

#define S_FREE_MASK 1

   445

   446

static inline MemBlock* NextBlock(MemBlock* block)

   447

{

   448

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

   449

}

   450

   451

static uint32 GetSpriteCacheUsage(void)

   452

{

   453

	size_t tot_size = 0;

   454

	MemBlock* s;

   455

   456

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

   457

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

   458

   459

	return tot_size;

   460

}

   461

   462

   463

void IncreaseSpriteLRU(void)

   464

{

   465

	int i;

   466

   467

	// Increase all LRU values

   468

#if defined(WANT_NEW_LRU)

   469

	if (_sprite_lru_counter > 16384) {

   470

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

   471

   472

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

   473

			if (_sprite_ptr[i] != NULL) {

   474

				if (_sprite_lru_new[i] >= 0) {

   475

					_sprite_lru_new[i] = -1;

   476

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

   477

					_sprite_lru_new[i]--;

   478

				}

   479

			}

   480

		_sprite_lru_counter = 0;

   481

	}

   482

#else

   483

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

   484

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

   485

			_sprite_lru[i]++;

   486

	// Reset the lru counter.

   487

	_sprite_lru_counter = 0;

   488

#endif

   489

   490

	// Compact sprite cache every now and then.

   491

	if (++_compact_cache_counter >= 740) {

   492

		CompactSpriteCache();

   493

		_compact_cache_counter = 0;

   494

	}

   495

}

   496

   497

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

   498

// That is accomplished by moving the cached data.

   499

static void CompactSpriteCache(void)

   500

{

   501

	MemBlock *s;

   502