1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     5

#include "gfx.h"

     6

#include "spritecache.h"

     7

#include "table/sprites.h"

     8

#include "fileio.h"

     9

#include "newgrf.h"

    10

#include "md5.h"

    11

#include "variables.h"

    12

#include <ctype.h>

    13

    14

#define SPRITECACHE_ID 0xF00F0006

    15

#define SPRITE_CACHE_SIZE 1024*1024

    16

    17

    18

//#define WANT_SPRITESIZES

    19

#define WANT_NEW_LRU

    20

//#define WANT_LOCKED

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

    37

static uint16 _sprite_size[NUM_SPRITES];

    38

static uint32 _sprite_file_pos[NUM_SPRITES];

    39

    40

// This one is probably not needed.

    41

#if defined(WANT_LOCKED)

    42

static bool _sprite_locked[NUM_SPRITES];

    43

#endif

    44

    45

#if defined(WANT_NEW_LRU)

    46

static int16 _sprite_lru_new[NUM_SPRITES];

    47

#else

    48

static uint16 _sprite_lru[NUM_SPRITES];

    49

static uint16 _sprite_lru_cur[NUM_SPRITES];

    50

#endif

    51

    52

#ifdef WANT_SPRITESIZES

    53

static int8 _sprite_xoffs[NUM_SPRITES];

    54

static int8 _sprite_yoffs[NUM_SPRITES];

    55

static uint16 _sprite_xsize[NUM_SPRITES];

    56

static uint8 _sprite_ysize[NUM_SPRITES];

    57

#endif

    58

    59

bool _cache_sprites;

    60

    61

typedef struct MemBlock {

    62

	uint32 size;

    63

	byte data[VARARRAY_SIZE];

    64

} MemBlock;

    65

    66

static uint _sprite_lru_counter;

    67

static MemBlock *_spritecache_ptr;

    68

static uint32 _spritecache_size;

    69

static int _compact_cache_counter;

    70

    71

typedef struct MD5File {

    72

	const char * const filename;     // filename

    73

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

    74

} MD5File;

    75

    76

typedef struct FileList {

    77

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

    78

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

    79

} FileList;

    80

    81

#include "table/files.h"

    82

#include "table/landscape_sprite.h"

    83

    84

static const uint16 * const _landscape_spriteindexes[] = {

    85

	_landscape_spriteindexes_1,

    86

	_landscape_spriteindexes_2,

    87

	_landscape_spriteindexes_3,

    88

};

    89

    90

static const uint16 * const _slopes_spriteindexes[] = {

    91

	_slopes_spriteindexes_0,

    92

	_slopes_spriteindexes_1,

    93

	_slopes_spriteindexes_2,

    94

	_slopes_spriteindexes_3,

    95

};

    96

    97

static void CompactSpriteCache(void);

    98

    99

static void ReadSpriteHeaderSkipData(int num, int load_index)

   100

{

   101

	byte type;

   102

	int deaf = 0;

   103

   104

	if (_skip_sprites) {

   105

		if (_skip_sprites > 0)

   106

			_skip_sprites--;

   107

		deaf = 1;

   108

	}

   109

   110

	type = FioReadByte();

   111

	_cur_sprite.info = type;

   112

	if (type == 0xFF) {

   113

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

   114

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

   115

		 * because if no special sprite referencing to them is

   116

		 * processed, they themselves are never referenced and loaded

   117

		 * on their own. */

   118

		if (_skip_specials || deaf) {

   119

			FioSkipBytes(num);

   120

		} else {

   121

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   122

		}

   123

		return;

   124

	}

   125

   126

#ifdef WANT_SPRITESIZES

   127

	_cur_sprite.height = FioReadByte();

   128

	_cur_sprite.width = FioReadWord();

   129

	_cur_sprite.x_offs = FioReadWord();

   130

	_cur_sprite.y_offs = FioReadWord();

   131

#else

   132

	FioSkipBytes(7);

   133

#endif

   134

	num -= 8;

   135

	if (num == 0)

   136

		return;

   137

   138

	if (type & 2) {

   139

		FioSkipBytes(num);

   140

	} else {

   141

		while (num > 0) {

   142

			int8 i = FioReadByte();

   143

			if (i >= 0) {

   144

				num -= i;

   145

				FioSkipBytes(i);

   146

			} else {

   147

				i = -(i >> 3);

   148

				num -= i;

   149

				FioReadByte();

   150

			}

   151

		}

   152

	}

   153

}

   154

   155

static void* AllocSprite(size_t);

   156

   157

static void* ReadSprite(SpriteID id)

   158

{

   159

	uint num = _sprite_size[id];

   160

	byte type;

   161

   162

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

   163

   164

	if (_sprite_file_pos[id] == 0) {

   165

		error(

   166

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

   167

			"Probable cause: Wrong/missing NewGRFs",

   168

			id

   169

		);

   170

	}

   171

   172

	FioSeekToFile(_sprite_file_pos[id]);

   173

   174

	type = FioReadByte();

   175

	if (type == 0xFF) {

   176

		byte* dest = AllocSprite(num);

   177

   178

		_sprite_ptr[id] = dest;

   179

		FioReadBlock(dest, num);

   180

   181

		return dest;

   182

	} else {

   183

		uint height = FioReadByte();

   184

		uint width  = FioReadWord();

   185

		Sprite* sprite;

   186

		byte* dest;

   187

   188

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

   189

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

   190

		_sprite_ptr[id] = sprite;

   191

		sprite->info   = type;

   192

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

   193

		sprite->width  = width;

   194

		sprite->x_offs = FioReadWord();

   195

		sprite->y_offs = FioReadWord();

   196

   197

		dest = sprite->data;

   198

		while (num > 0) {

   199

			int8 i = FioReadByte();

   200

   201

			if (i >= 0) {

   202

				num -= i;

   203

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

   204

			} else {

   205

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

   206

   207

				i = -(i >> 3);

   208

				num -= i;

   209

   210

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

   211

			}

   212

		}

   213

   214

		return sprite;

   215

	}

   216

}

   217

   218

   219

static bool LoadNextSprite(int load_index, byte file_index)

   220

{

   221

	uint16 size;

   222

	uint32 file_pos;

   223

   224

	size = FioReadWord();

   225

	if (size == 0)

   226

		return false;

   227

   228

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

   229

   230

	ReadSpriteHeaderSkipData(size, load_index);

   231

   232

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

   233

		int count = _replace_sprites_count[0];

   234

		int offset = _replace_sprites_offset[0];

   235

   236

		_replace_sprites_offset[0]++;

   237

		_replace_sprites_count[0]--;

   238

   239

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

   240

			load_index = offset;

   241

		} else {

   242

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

   243

					count, offset);

   244

			_replace_sprites_offset[0] = 0;

   245

			_replace_sprites_count[0] = 0;

   246

		}

   247

   248

		if (_replace_sprites_count[0] == 0) {

   249

			int i;

   250

   251

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

   252

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

   253

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

   254

			}

   255

			_replace_sprites_count[i] = 0;

   256

			_replace_sprites_offset[i] = 0;

   257

		}

   258

	}

   259

   260

	_sprite_size[load_index] = size;

   261

	_sprite_file_pos[load_index] = file_pos;

   262

   263

#ifdef WANT_SPRITESIZES

   264

	_sprite_xsize[load_index] = _cur_sprite.width;

   265

	_sprite_ysize[load_index] = _cur_sprite.height;

   266

   267

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   268

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   269

#endif

   270

   271

	_sprite_ptr[load_index] = NULL;

   272

#if defined(WANT_LOCKED)

   273

	_sprite_locked[load_index] = false;

   274

#endif

   275

   276

#if defined(WANT_NEW_LRU)

   277

	_sprite_lru_new[load_index] = 0;

   278

#else

   279

	_sprite_lru[load_index] = 0xFFFF;

   280

	_sprite_lru_cur[load_index] = 0;

   281

#endif

   282

   283

	return true;

   284

}

   285

   286

static void SkipSprites(uint count)

   287

{

   288

	for (; count > 0; --count)

   289

	{

   290

		uint16 size = FioReadWord();

   291

   292

		if (size == 0)

   293

			return;

   294

   295

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   296

	}

   297

}

   298

   299

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

   300

{

   301

	int load_index_org = load_index;

   302

   303

	FioOpenFile(file_index, filename);

   304

   305

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

   306

	 * might contain some special sprites. */

   307

	_skip_specials = 1;

   308

	_skip_sprites = 0;

   309

   310

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

   311

   312

	while (LoadNextSprite(load_index, file_index)) {

   313

		load_index++;

   314

		if (load_index >= NUM_SPRITES) {

   315

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

   316

		}

   317

	}

   318

   319

	return load_index - load_index_org;

   320

}

   321

   322

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

   323

{

   324

	int i;

   325

   326

	FioOpenFile(file_index, filename);

   327

	_cur_grffile = filename;

   328

	_skip_specials = 0;

   329

	_skip_sprites = 0;

   330

   331

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

   332

			filename, load_index);

   333

   334

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

   335

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

   336

	 * neither, apparently. */

   337

	{

   338

		int length;

   339

		byte type;

   340

   341

		length = FioReadWord();

   342

		type = FioReadByte();

   343

   344

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

   345

			FioReadDword();

   346

		} else {

   347

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

   348

		}

   349

	}

   350

   351

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

   352

		if (load_index + i >= NUM_SPRITES)

   353

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

   354

			      load_index + i);

   355

	}

   356

   357

	/* Clean up. */

   358

	_skip_sprites = 0;

   359

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

   360

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

   361

   362

	return i;

   363

}

   364

   365

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

   366

{

   367

	int start;

   368

   369

	FioOpenFile(file_index, filename);

   370

	_skip_specials = 1;

   371

	_skip_sprites = 0;

   372

   373

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

   374

   375

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

   376

		int end = *index_tbl++;

   377

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

   378

			SkipSprites(end);

   379

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

   380

			do {

   381

			#ifdef NDEBUG

   382

				LoadNextSprite(start, file_index);

   383

			#else

   384

				bool b = LoadNextSprite(start, file_index);

   385

				assert(b);

   386

			#endif

   387

			} while (++start <= end);

   388

		}

   389

	}

   390

}

   391

   392

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

   393

   394

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

   395

{

   396

	FILE *f;

   397

	fread_t *proc;

   398

	uint32 hdr;

   399

   400

	if (!_cache_sprites)

   401

		return false;

   402

   403

	if (read) {

   404

		f = fopen(filename, "rb");

   405

		proc = fread;

   406

   407

		if (f == NULL)

   408

			return false;

   409

   410

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

   411

		if (hdr != SPRITECACHE_ID) {

   412

			fclose(f);

   413

			return false;

   414

		}

   415

	} else {

   416

		f = fopen(filename, "wb");

   417

		proc = (fread_t*) fwrite;

   418

   419

		if (f == NULL)

   420

			return false;

   421

   422

		hdr = SPRITECACHE_ID;

   423

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

   424

	}

   425

   426

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

   427

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

   428

   429

#if 0

   430

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

   431

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

   432

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

   433

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

   434

#endif

   435

   436

#if !defined(WANT_NEW_LRU)

   437

	if (read)

   438

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

   439

#endif

   440

   441

	fclose(f);

   442

	return true;

   443

}

   444

   445

#define S_FREE_MASK 1

   446

   447

static inline MemBlock* NextBlock(MemBlock* block)

   448

{

   449

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

   450

}

   451

   452

static uint32 GetSpriteCacheUsage(void)

   453

{

   454

	size_t tot_size = 0;

   455

	MemBlock* s;

   456

   457

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

   458

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

   459

   460

	return tot_size;

   461

}

   462

   463

   464

void IncreaseSpriteLRU(void)

   465

{

   466

	int i;

   467

   468

	// Increase all LRU values

   469

#if defined(WANT_NEW_LRU)

   470

	if (_sprite_lru_counter > 16384) {

   471

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

   472

   473

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

   474

			if (_sprite_ptr[i] != NULL) {

   475

				if (_sprite_lru_new[i] >= 0) {

   476

					_sprite_lru_new[i] = -1;

   477

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

   478

					_sprite_lru_new[i]--;

   479

				}

   480

			}

   481

		_sprite_lru_counter = 0;

   482

	}

   483

#else

   484

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

   485

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

   486

			_sprite_lru[i]++;

   487

	// Reset the lru counter.

   488

	_sprite_lru_counter = 0;

   489

#endif

   490

   491

	// Compact sprite cache every now and then.

   492

	if (++_compact_cache_counter >= 740) {

   493

		CompactSpriteCache();

   494

		_compact_cache_counter = 0;

   495

	}

   496

}

   497

   498

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

   499

// That is accomplished by moving the cached data.

   500

static void CompactSpriteCache(void)

   501

{

   502

	MemBlock *s;