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 SPRITECACHE_ID 0xF00F0006

    17

#define SPRITE_CACHE_SIZE 1024*1024

    18

    19

    20

//#define WANT_SPRITESIZES

    21

#define WANT_NEW_LRU

    22

//#define WANT_LOCKED

    23

    24

    25

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

    26

    27

int _skip_sprites = 0;

    28

int _replace_sprites_count[16];

    29

int _replace_sprites_offset[16];

    30

    31

static const char *_cur_grffile;

    32

static int _loading_stage;

    33

static int _skip_specials;

    34

uint16 _custom_sprites_base;

    35

static Sprite _cur_sprite;

    36

    37

    38

static void* _sprite_ptr[NUM_SPRITES];

    39

static uint16 _sprite_size[NUM_SPRITES];

    40

static uint32 _sprite_file_pos[NUM_SPRITES];

    41

    42

// This one is probably not needed.

    43

#if defined(WANT_LOCKED)

    44

static bool _sprite_locked[NUM_SPRITES];

    45

#endif

    46

    47

#if defined(WANT_NEW_LRU)

    48

static int16 _sprite_lru_new[NUM_SPRITES];

    49

#else

    50

static uint16 _sprite_lru[NUM_SPRITES];

    51

static uint16 _sprite_lru_cur[NUM_SPRITES];

    52

#endif

    53

    54

#ifdef WANT_SPRITESIZES

    55

static int8 _sprite_xoffs[NUM_SPRITES];

    56

static int8 _sprite_yoffs[NUM_SPRITES];

    57

static uint16 _sprite_xsize[NUM_SPRITES];

    58

static uint8 _sprite_ysize[NUM_SPRITES];

    59

#endif

    60

    61

bool _cache_sprites;

    62

    63

typedef struct MemBlock {

    64

	uint32 size;

    65

	byte data[VARARRAY_SIZE];

    66

} MemBlock;

    67

    68

static uint _sprite_lru_counter;

    69

static MemBlock *_spritecache_ptr;

    70

static uint32 _spritecache_size;

    71

static int _compact_cache_counter;

    72

    73

typedef struct MD5File {

    74

	const char * const filename;     // filename

    75

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

    76

} MD5File;

    77

    78

typedef struct FileList {

    79

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

    80

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

    81

} FileList;

    82

    83

#include "table/files.h"

    84

#include "table/landscape_sprite.h"

    85

    86

static const uint16 * const _landscape_spriteindexes[] = {

    87

	_landscape_spriteindexes_1,

    88

	_landscape_spriteindexes_2,

    89

	_landscape_spriteindexes_3,

    90

};

    91

    92

static const uint16 * const _slopes_spriteindexes[] = {

    93

	_slopes_spriteindexes_0,

    94

	_slopes_spriteindexes_1,

    95

	_slopes_spriteindexes_2,

    96

	_slopes_spriteindexes_3,

    97

};

    98

    99

static void CompactSpriteCache(void);

   100

   101

static void ReadSpriteHeaderSkipData(int num, int load_index)

   102

{

   103

	byte type;

   104

	int deaf = 0;

   105

   106

	if (_skip_sprites) {

   107

		if (_skip_sprites > 0)

   108

			_skip_sprites--;

   109

		deaf = 1;

   110

	}

   111

   112

	type = FioReadByte();

   113

	_cur_sprite.info = type;

   114

	if (type == 0xFF) {

   115

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

   116

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

   117

		 * because if no special sprite referencing to them is

   118

		 * processed, they themselves are never referenced and loaded

   119

		 * on their own. */

   120

		if (_skip_specials || deaf) {

   121

			FioSkipBytes(num);

   122

		} else {

   123

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   124

		}

   125

		return;

   126

	}

   127

   128

#ifdef WANT_SPRITESIZES

   129

	_cur_sprite.height = FioReadByte();

   130

	_cur_sprite.width = FioReadWord();

   131

	_cur_sprite.x_offs = FioReadWord();

   132

	_cur_sprite.y_offs = FioReadWord();

   133

#else

   134

	FioSkipBytes(7);

   135

#endif

   136

	num -= 8;

   137

	if (num == 0)

   138

		return;

   139

   140

	if (type & 2) {

   141

		FioSkipBytes(num);

   142

	} else {

   143

		while (num > 0) {

   144

			int8 i = FioReadByte();

   145

			if (i >= 0) {

   146

				num -= i;

   147

				FioSkipBytes(i);

   148

			} else {

   149

				i = -(i >> 3);

   150

				num -= i;

   151

				FioReadByte();

   152

			}

   153

		}

   154

	}

   155

}

   156

   157

static void* AllocSprite(size_t);

   158

   159

static void* ReadSprite(SpriteID id)

   160

{

   161

	uint num = _sprite_size[id];

   162

	byte type;

   163

   164

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

   165

   166

	if (_sprite_file_pos[id] == 0) {

   167

		error(

   168

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

   169

			"Probable cause: Wrong/missing NewGRFs",

   170

			id

   171

		);

   172

	}

   173

   174

	FioSeekToFile(_sprite_file_pos[id]);

   175

   176

	type = FioReadByte();

   177

	if (type == 0xFF) {

   178

		byte* dest = AllocSprite(num);

   179

   180

		_sprite_ptr[id] = dest;

   181

		FioReadBlock(dest, num);

   182

   183

		return dest;

   184

	} else {

   185

		uint height = FioReadByte();

   186

		uint width  = FioReadWord();

   187

		Sprite* sprite;

   188

		byte* dest;

   189

   190

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

   191

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

   192

		_sprite_ptr[id] = sprite;

   193

		sprite->info   = type;

   194

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

   195

		sprite->width  = width;

   196

		sprite->x_offs = FioReadWord();

   197

		sprite->y_offs = FioReadWord();

   198

   199

		dest = sprite->data;

   200

		while (num > 0) {

   201

			int8 i = FioReadByte();

   202

   203

			if (i >= 0) {

   204

				num -= i;

   205

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

   206

			} else {

   207

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

   208

   209

				i = -(i >> 3);

   210

				num -= i;

   211

   212

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

   213

			}

   214

		}

   215

   216

		return sprite;

   217

	}

   218

}

   219

   220

   221

static bool LoadNextSprite(int load_index, byte file_index)

   222

{

   223

	uint16 size;

   224

	uint32 file_pos;

   225

   226

	size = FioReadWord();

   227

	if (size == 0)

   228

		return false;

   229

   230

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

   231

   232

	ReadSpriteHeaderSkipData(size, load_index);

   233

   234

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

   235

		int count = _replace_sprites_count[0];

   236

		int offset = _replace_sprites_offset[0];

   237

   238

		_replace_sprites_offset[0]++;

   239

		_replace_sprites_count[0]--;

   240

   241

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

   242

			load_index = offset;

   243

		} else {

   244

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

   245

					count, offset);

   246

			_replace_sprites_offset[0] = 0;

   247

			_replace_sprites_count[0] = 0;

   248

		}

   249

   250

		if (_replace_sprites_count[0] == 0) {

   251

			int i;

   252

   253

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

   254

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

   255

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

   256

			}

   257

			_replace_sprites_count[i] = 0;

   258

			_replace_sprites_offset[i] = 0;

   259

		}

   260

	}

   261

   262

	_sprite_size[load_index] = size;

   263

	_sprite_file_pos[load_index] = file_pos;

   264

   265

#ifdef WANT_SPRITESIZES

   266

	_sprite_xsize[load_index] = _cur_sprite.width;

   267

	_sprite_ysize[load_index] = _cur_sprite.height;

   268

   269

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   270

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   271

#endif

   272

   273

	_sprite_ptr[load_index] = NULL;

   274

#if defined(WANT_LOCKED)

   275

	_sprite_locked[load_index] = false;

   276

#endif

   277

   278

#if defined(WANT_NEW_LRU)

   279

	_sprite_lru_new[load_index] = 0;

   280

#else

   281

	_sprite_lru[load_index] = 0xFFFF;

   282

	_sprite_lru_cur[load_index] = 0;

   283

#endif

   284

   285

	return true;

   286

}

   287

   288

static void SkipSprites(uint count)

   289

{

   290

	for (; count > 0; --count)

   291

	{

   292

		uint16 size = FioReadWord();

   293

   294

		if (size == 0)

   295

			return;

   296

   297

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   298

	}

   299

}

   300

   301

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

   302

{

   303

	int load_index_org = load_index;

   304

   305

	FioOpenFile(file_index, filename);

   306

   307

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

   308

	 * might contain some special sprites. */

   309

	_skip_specials = 1;

   310

	_skip_sprites = 0;

   311

   312

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

   313

   314

	while (LoadNextSprite(load_index, file_index)) {

   315

		load_index++;

   316

		if (load_index >= NUM_SPRITES) {

   317

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

   318

		}

   319

	}

   320

   321

	return load_index - load_index_org;

   322

}

   323

   324

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

   325

{

   326

	int i;

   327

   328

	FioOpenFile(file_index, filename);

   329

	_cur_grffile = filename;

   330

	_skip_specials = 0;

   331

	_skip_sprites = 0;

   332

   333

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

   334

			filename, load_index);

   335

   336

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

   337

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

   338

	 * neither, apparently. */

   339

	{

   340

		int length;

   341

		byte type;

   342

   343

		length = FioReadWord();

   344

		type = FioReadByte();

   345

   346

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

   347

			FioReadDword();

   348

		} else {

   349

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

   350

		}

   351

	}

   352

   353

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

   354

		if (load_index + i >= NUM_SPRITES)

   355

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

   356

			      load_index + i);

   357

	}

   358

   359

	/* Clean up. */

   360

	_skip_sprites = 0;

   361

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

   362

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

   363

   364

	return i;

   365

}

   366

   367

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

   368

{

   369

	int start;

   370

   371

	FioOpenFile(file_index, filename);

   372

	_skip_specials = 1;

   373

	_skip_sprites = 0;

   374

   375

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

   376

   377

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

   378

		int end = *index_tbl++;

   379

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

   380

			SkipSprites(end);

   381

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

   382

			do {

   383

			#ifdef NDEBUG

   384

				LoadNextSprite(start, file_index);

   385

			#else

   386

				bool b = LoadNextSprite(start, file_index);

   387

				assert(b);

   388

			#endif

   389

			} while (++start <= end);

   390

		}

   391

	}

   392

}

   393

   394

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

   395

   396

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

   397

{

   398

	FILE *f;

   399

	fread_t *proc;

   400

	uint32 hdr;

   401

   402

	if (!_cache_sprites)

   403

		return false;

   404

   405

	if (read) {

   406

		f = fopen(filename, "rb");

   407

		proc = fread;

   408

   409

		if (f == NULL)

   410

			return false;

   411

   412

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

   413

		if (hdr != SPRITECACHE_ID) {

   414

			fclose(f);

   415

			return false;

   416

		}

   417

	} else {

   418

		f = fopen(filename, "wb");

   419

		proc = (fread_t*) fwrite;

   420

   421

		if (f == NULL)

   422

			return false;

   423

   424

		hdr = SPRITECACHE_ID;

   425

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

   426

	}

   427

   428

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

   429

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

   430

   431

#if 0

   432

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

   433

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

   434

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

   435

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

   436

#endif

   437

   438

#if !defined(WANT_NEW_LRU)

   439

	if (read)

   440

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

   441

#endif

   442

   443

	fclose(f);

   444

	return true;

   445

}

   446

   447

#define S_FREE_MASK 1

   448

   449

static inline MemBlock* NextBlock(MemBlock* block)

   450

{

   451

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

   452

}

   453

   454

static uint32 GetSpriteCacheUsage(void)

   455

{

   456

	size_t tot_size = 0;

   457

	MemBlock* s;

   458

   459

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

   460

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

   461

   462

	return tot_size;

   463

}

   464

   465

   466

void IncreaseSpriteLRU(void)

   467

{

   468

	int i;

   469

   470

	// Increase all LRU values

   471

#if defined(WANT_NEW_LRU)

   472

	if (_sprite_lru_counter > 16384) {

   473

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

   474

   475

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

   476

			if (_sprite_ptr[i] != NULL) {

   477

				if (_sprite_lru_new[i] >= 0) {

   478

					_sprite_lru_new[i] = -1;

   479

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

   480

					_sprite_lru_new[i]--;

   481

				}

   482

			}

   483

		_sprite_lru_counter = 0;

   484

	}

   485

#else

   486

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

   487

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

   488

			_sprite_lru[i]++;

   489

	// Reset the lru counter.

   490

	_sprite_lru_counter = 0;

   491

#endif

   492

   493

	// Compact sprite cache every now and then.

   494

	if (++_compact_cache_counter >= 740) {

   495

		CompactSpriteCache();

   496

		_compact_cache_counter = 0;

   497

	}

   498

}

   499

   500

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

   501

// That is accomplished by moving the cached data.

   502

static void CompactSpriteCache(void)