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 <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 void* _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

bool _cache_sprites;

    58

    59

typedef struct MemBlock {

    60

	uint32 size;

    61

	byte data[VARARRAY_SIZE];

    62

} MemBlock;

    63

    64

static uint _sprite_lru_counter;

    65

static MemBlock *_spritecache_ptr;

    66

static uint32 _spritecache_size;

    67

static int _compact_cache_counter;

    68

    69

typedef struct MD5File {

    70

	const char * const filename;     // filename

    71

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

    72

} MD5File;

    73

    74

typedef struct FileList {

    75

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

    76

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

    77

} FileList;

    78

    79

#include "table/files.h"

    80

#include "table/landscape_sprite.h"

    81

    82

static const uint16 * const _landscape_spriteindexes[] = {

    83

	_landscape_spriteindexes_1,

    84

	_landscape_spriteindexes_2,

    85

	_landscape_spriteindexes_3,

    86

};

    87

    88

static const uint16 * const _slopes_spriteindexes[] = {

    89

	_slopes_spriteindexes_0,

    90

	_slopes_spriteindexes_1,

    91

	_slopes_spriteindexes_2,

    92

	_slopes_spriteindexes_3,

    93

};

    94

    95

static void CompactSpriteCache(void);

    96

    97

static void ReadSpriteHeaderSkipData(int num, int load_index)

    98

{

    99

	byte type;

   100

	int deaf = 0;

   101

   102

	if (_skip_sprites) {

   103

		if (_skip_sprites > 0)

   104

			_skip_sprites--;

   105

		deaf = 1;

   106

	}

   107

   108

	type = FioReadByte();

   109

	_cur_sprite.info = type;

   110

	if (type == 0xFF) {

   111

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

   112

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

   113

		 * because if no special sprite referencing to them is

   114

		 * processed, they themselves are never referenced and loaded

   115

		 * on their own. */

   116

		if (_skip_specials || deaf) {

   117

			FioSkipBytes(num);

   118

		} else {

   119

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   120

		}

   121

		return;

   122

	}

   123

   124

#ifdef WANT_SPRITESIZES

   125

	_cur_sprite.height = FioReadByte();

   126

	_cur_sprite.width = FioReadWord();

   127

	_cur_sprite.x_offs = FioReadWord();

   128

	_cur_sprite.y_offs = FioReadWord();

   129

#else

   130

	FioSkipBytes(7);

   131

#endif

   132

	num -= 8;

   133

	if (num == 0)

   134

		return;

   135

   136

	if (type & 2) {

   137

		FioSkipBytes(num);

   138

	} else {

   139

		while (num > 0) {

   140

			int8 i = FioReadByte();

   141

			if (i >= 0) {

   142

				num -= i;

   143

				FioSkipBytes(i);

   144

			} else {

   145

				i = -(i >> 3);

   146

				num -= i;

   147

				FioReadByte();

   148

			}

   149

		}

   150

	}

   151

}

   152

   153

static void* AllocSprite(size_t);

   154

   155

static void* ReadSprite(SpriteID id)

   156

{

   157

	uint num = _sprite_size[id];

   158

	byte type;

   159

   160

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

   161

   162

	if (_sprite_file_pos[id] == 0) {

   163

		error(

   164

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

   165

			"Probable cause: Wrong/missing NewGRFs",

   166

			id

   167

		);

   168

	}

   169

   170

	FioSeekToFile(_sprite_file_pos[id]);

   171

   172

	type = FioReadByte();

   173

	if (type == 0xFF) {

   174

		byte* dest = AllocSprite(num);

   175

   176

		_sprite_ptr[id] = dest;

   177

		FioReadBlock(dest, num);

   178

   179

		return dest;

   180

	} else {

   181

		uint height = FioReadByte();

   182

		uint width  = FioReadWord();

   183

		Sprite* sprite;

   184

		byte* dest;

   185

   186

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

   187

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

   188

		_sprite_ptr[id] = sprite;

   189

		sprite->info   = type;

   190

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

   191

		sprite->width  = width;

   192

		sprite->x_offs = FioReadWord();

   193

		sprite->y_offs = FioReadWord();

   194

   195

		dest = sprite->data;

   196

		while (num > 0) {

   197

			int8 i = FioReadByte();

   198

   199

			if (i >= 0) {

   200

				num -= i;

   201

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

   202

			} else {

   203

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

   204

   205

				i = -(i >> 3);

   206

				num -= i;

   207

   208

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

   209

			}

   210

		}

   211

   212

		return sprite;

   213

	}

   214

}

   215

   216

   217

static bool LoadNextSprite(int load_index, byte file_index)

   218

{

   219

	uint16 size;

   220

	uint32 file_pos;

   221

   222

	size = FioReadWord();

   223

	if (size == 0)

   224

		return false;

   225

   226

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

   227

   228

	ReadSpriteHeaderSkipData(size, load_index);

   229

   230

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

   231

		int count = _replace_sprites_count[0];

   232

		int offset = _replace_sprites_offset[0];

   233

   234

		_replace_sprites_offset[0]++;

   235

		_replace_sprites_count[0]--;

   236

   237

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

   238

			load_index = offset;

   239

		} else {

   240

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

   241

					count, offset);

   242

			_replace_sprites_offset[0] = 0;

   243

			_replace_sprites_count[0] = 0;

   244

		}

   245

   246

		if (_replace_sprites_count[0] == 0) {

   247

			int i;

   248

   249

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

   250

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

   251

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

   252

			}

   253

			_replace_sprites_count[i] = 0;

   254

			_replace_sprites_offset[i] = 0;

   255

		}

   256

	}

   257

   258

	_sprite_size[load_index] = size;

   259

	_sprite_file_pos[load_index] = file_pos;

   260

   261

#ifdef WANT_SPRITESIZES

   262

	_sprite_xsize[load_index] = _cur_sprite.width;

   263

	_sprite_ysize[load_index] = _cur_sprite.height;

   264

   265

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   266

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   267

#endif

   268

   269

	_sprite_ptr[load_index] = NULL;

   270

#if defined(WANT_LOCKED)

   271

	_sprite_locked[load_index] = false;

   272

#endif

   273

   274

#if defined(WANT_NEW_LRU)

   275

	_sprite_lru_new[load_index] = 0;

   276

#else

   277

	_sprite_lru[load_index] = 0xFFFF;

   278

	_sprite_lru_cur[load_index] = 0;

   279

#endif

   280

   281

	return true;

   282

}

   283

   284

static void SkipSprites(uint count)

   285

{

   286

	for (; count > 0; --count)

   287

	{

   288

		uint16 size = FioReadWord();

   289

   290

		if (size == 0)

   291

			return;

   292

   293

		ReadSpriteHeaderSkipData(size, NUM_SPRITES - 1);

   294

	}

   295

}

   296

   297

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

   298

{

   299

	int load_index_org = load_index;

   300

   301

	FioOpenFile(file_index, filename);

   302

   303

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

   304

	 * might contain some special sprites. */

   305

	_skip_specials = 1;

   306

	_skip_sprites = 0;

   307

   308

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

   309

   310

	while (LoadNextSprite(load_index, file_index)) {

   311

		load_index++;

   312

		if (load_index >= NUM_SPRITES) {

   313

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

   314

		}

   315

	}

   316

   317

	return load_index - load_index_org;

   318

}

   319

   320

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

   321

{

   322

	int i;

   323

   324

	FioOpenFile(file_index, filename);

   325

	_cur_grffile = filename;

   326

	_skip_specials = 0;

   327

	_skip_sprites = 0;

   328

   329

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

   330

			filename, load_index);

   331

   332

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

   333

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

   334

	 * neither, apparently. */

   335

	{

   336

		int length;

   337

		byte type;

   338

   339

		length = FioReadWord();

   340

		type = FioReadByte();

   341

   342

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

   343

			FioReadDword();

   344

		} else {

   345

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

   346

		}

   347

	}

   348

   349

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

   350

		if (load_index + i >= NUM_SPRITES)

   352

			      load_index + i);

   353

	}

   354

   355

	/* Clean up. */

   356

	_skip_sprites = 0;

   357

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

   358

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

   359

   360

	return i;

   361

}

   362

   363

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

   364

{

   365

	int start;

   366

   367

	FioOpenFile(file_index, filename);

   368

	_skip_specials = 1;

   369

	_skip_sprites = 0;

   370

   371

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

   372

   373

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

   374

		int end = *index_tbl++;

   375

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

   376

			SkipSprites(end);

   377

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

   378

			do {

   379

			#ifdef NDEBUG

   380

				LoadNextSprite(start, file_index);

   381

			#else

   382

				bool b = LoadNextSprite(start, file_index);

   383

				assert(b);

   384

			#endif

   385

			} while (++start <= end);

   386

		}

   387

	}

   388

}

   389

   390

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

   391

   392

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

   393

{

   394

	FILE *f;

   395

	fread_t *proc;

   396

	uint32 hdr;

   397

   398

	if (!_cache_sprites)

   399

		return false;

   400

   401

	if (read) {

   402

		f = fopen(filename, "rb");

   403

		proc = fread;

   404

   405

		if (f == NULL)

   406

			return false;

   407

   408

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

   409

		if (hdr != SPRITECACHE_ID) {

   410

			fclose(f);

   411

			return false;

   412

		}

   413

	} else {

   414

		f = fopen(filename, "wb");

   415

		proc = (fread_t*) fwrite;

   416

   417

		if (f == NULL)

   418

			return false;

   419

   420

		hdr = SPRITECACHE_ID;

   421

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

   422

	}

   423

   424

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

   425

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

   426

   427

#if 0

   428

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

   429

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

   430

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

   431

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

   432

#endif

   433

   434

#if !defined(WANT_NEW_LRU)

   435

	if (read)

   436

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

   437

#endif

   438

   439

	fclose(f);

   440

	return true;

   441

}

   442

   443

#define S_FREE_MASK 1

   444

   445

static inline MemBlock* NextBlock(MemBlock* block)

   446

{

   447

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

   448

}

   449

   450

static uint32 GetSpriteCacheUsage(void)

   451

{

   452

	size_t tot_size = 0;

   453

	MemBlock* s;

   454

   455

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

   456

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

   457

   458

	return tot_size;

   459

}

   460

   461

   462

void IncreaseSpriteLRU(void)

   463

{

   464

	int i;

   465

   466

	// Increase all LRU values

   467

#if defined(WANT_NEW_LRU)

   468

	if (_sprite_lru_counter > 16384) {

   469

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

   470

   471

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

   472

			if (_sprite_ptr[i] != NULL) {

   473

				if (_sprite_lru_new[i] >= 0) {

   474

					_sprite_lru_new[i] = -1;

   475

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

   476

					_sprite_lru_new[i]--;

   477

				}

   478

			}

   479

		_sprite_lru_counter = 0;

   480

	}

   481

#else

   482

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

   483

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

   484

			_sprite_lru[i]++;

   485

	// Reset the lru counter.

   486

	_sprite_lru_counter = 0;

   487

#endif

   488

   489

	// Compact sprite cache every now and then.

   490

	if (++_compact_cache_counter >= 740) {

   491

		CompactSpriteCache();

   492

		_compact_cache_counter = 0;

   493

	}

   494

}

   495

   496

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

   497

// That is accomplished by moving the cached data.

   498

static void CompactSpriteCache(void)

   499

{

   500

	MemBlock *s;

   501

   502

	DEBUG(spritecache, 2) (