1

/* $Id$ */

     2

     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

    23

    24

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

    25

    26

int _skip_sprites = 0;

    27

int _replace_sprites_count[16];

    28

int _replace_sprites_offset[16];

    29

    30

static const char *_cur_grffile;

    31

static int _loading_stage;

    32

static int _skip_specials;

    33

uint16 _custom_sprites_base;

    34

static Sprite _cur_sprite;

    35

    36

    37

static void* _sprite_ptr[MAX_SPRITES];

    38

static uint16 _sprite_size[MAX_SPRITES];

    39

static uint32 _sprite_file_pos[MAX_SPRITES];

    40

    41

#if defined(WANT_NEW_LRU)

    42

static int16 _sprite_lru_new[MAX_SPRITES];

    43

#else

    44

static uint16 _sprite_lru[MAX_SPRITES];

    45

static uint16 _sprite_lru_cur[MAX_SPRITES];

    46

#endif

    47

    48

#ifdef WANT_SPRITESIZES

    49

static int8 _sprite_xoffs[MAX_SPRITES];

    50

static int8 _sprite_yoffs[MAX_SPRITES];

    51

static uint16 _sprite_xsize[MAX_SPRITES];

    52

static uint8 _sprite_ysize[MAX_SPRITES];

    53

#endif

    54

    55

bool _cache_sprites;

    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[5];     // 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 SpriteID * const _landscape_spriteindexes[] = {

    81

	_landscape_spriteindexes_1,

    82

	_landscape_spriteindexes_2,

    83

	_landscape_spriteindexes_3,

    84

};

    85

    86

static const SpriteID * 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* AllocSprite(size_t);

   152

   153

static void* ReadSprite(SpriteID id)

   154

{

   155

	uint num = _sprite_size[id];

   156

	byte type;

   157

   158

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

   159

   160

	if (_sprite_file_pos[id] == 0) {

   161

		error(

   162

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

   163

			"Probable cause: Wrong/missing NewGRFs",

   164

			id

   165

		);

   166

	}

   167

   168

	FioSeekToFile(_sprite_file_pos[id]);

   169

   170

	type = FioReadByte();

   171

	if (type == 0xFF) {

   172

		byte* dest = AllocSprite(num);

   173

   174

		_sprite_ptr[id] = dest;

   175

		FioReadBlock(dest, num);

   176

   177

		return dest;

   178

	} else {

   179

		uint height = FioReadByte();

   180

		uint width  = FioReadWord();

   181

		Sprite* sprite;

   182

		byte* dest;

   183

   184

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

   185

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

   186

		_sprite_ptr[id] = sprite;

   187

		sprite->info   = type;

   188

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

   189

		sprite->width  = width;

   190

		sprite->x_offs = FioReadWord();

   191

		sprite->y_offs = FioReadWord();

   192

   193

		dest = sprite->data;

   194

		while (num > 0) {

   195

			int8 i = FioReadByte();

   196

   197

			if (i >= 0) {

   198

				num -= i;

   199

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

   200

			} else {

   201

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

   202

   203

				i = -(i >> 3);

   204

				num -= i;

   205

   206

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

   207

			}

   208

		}

   209

   210

		return sprite;

   211

	}

   212

}

   213

   214

   215

static bool LoadNextSprite(int load_index, byte file_index)

   216

{

   217

	uint16 size;

   218

	uint32 file_pos;

   219

   220

	size = FioReadWord();

   221

	if (size == 0)

   222

		return false;

   223

   224

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

   225

   226

	ReadSpriteHeaderSkipData(size, load_index);

   227

   228

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

   229

		int count = _replace_sprites_count[0];

   230

		int offset = _replace_sprites_offset[0];

   231

   232

		_replace_sprites_offset[0]++;

   233

		_replace_sprites_count[0]--;

   234

   235

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

   236

			load_index = offset;

   237

		} else {

   238

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

   239

					count, offset);

   240

			_replace_sprites_offset[0] = 0;

   241

			_replace_sprites_count[0] = 0;

   242

		}

   243

   244

		if (_replace_sprites_count[0] == 0) {

   245

			int i;

   246

   247

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

   248

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

   249

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

   250

			}

   251

			_replace_sprites_count[i] = 0;

   252

			_replace_sprites_offset[i] = 0;

   253

		}

   254

	}

   255

   256

	_sprite_size[load_index] = size;

   257

	_sprite_file_pos[load_index] = file_pos;

   258

   259

#ifdef WANT_SPRITESIZES

   260

	_sprite_xsize[load_index] = _cur_sprite.width;

   261

	_sprite_ysize[load_index] = _cur_sprite.height;

   262

   263

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   264

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   265

#endif

   266

   267

	_sprite_ptr[load_index] = NULL;

   268

   269

#if defined(WANT_NEW_LRU)

   270

	_sprite_lru_new[load_index] = 0;

   271

#else

   272

	_sprite_lru[load_index] = 0xFFFF;

   273

	_sprite_lru_cur[load_index] = 0;

   274

#endif

   275

   276

	return true;

   277

}

   278

   279

static void SkipSprites(uint count)

   280

{

   281

	for (; count > 0; --count)

   282

	{

   283

		uint16 size = FioReadWord();

   284

   285

		if (size == 0)

   286

			return;

   287

   288

		ReadSpriteHeaderSkipData(size, MAX_SPRITES - 1);

   289

	}

   290

}

   291

   292

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

   293

{

   294

	int load_index_org = load_index;

   295

   296

	FioOpenFile(file_index, filename);

   297

   298

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

   299

	 * might contain some special sprites. */

   300

	_skip_specials = 1;

   301

	_skip_sprites = 0;

   302

   303

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

   304

   305

	while (LoadNextSprite(load_index, file_index)) {

   306

		load_index++;

   307

		if (load_index >= MAX_SPRITES) {

   308

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

   309

		}

   310

	}

   311

	DEBUG(spritecache, 2) ("Currently %i sprites are loaded", load_index);

   312

   313

	return load_index - load_index_org;

   314

}

   315

   316

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

   317

{

   318

	int i;

   319

   320

	FioOpenFile(file_index, filename);

   321

	_cur_grffile = filename;

   322

	_skip_specials = 0;

   323

	_skip_sprites = 0;

   324

   325

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

   326

			filename, load_index);

   327

   328

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

   329

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

   330

	 * neither, apparently. */

   331

	{

   332

		int length;

   333

		byte type;

   334

   335

		length = FioReadWord();

   336

		type = FioReadByte();

   337

   338

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

   339

			FioReadDword();

   340

		} else {

   341

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

   342

		}

   343

	}

   344

   345

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

   346

		if (load_index + i >= MAX_SPRITES)

   347

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

   348

			      load_index + i);

   349

	}

   350

   351

	/* Clean up. */

   352

	_skip_sprites = 0;

   353

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

   354

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

   355

   356

	return i;

   357

}

   358

   359

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

   360

{

   361

	int start;

   362

   363

	FioOpenFile(file_index, filename);

   364

	_skip_specials = 1;

   365

	_skip_sprites = 0;

   366

   367

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

   368

   369

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

   370

		int end = *index_tbl++;

   371

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

   372

			SkipSprites(end);

   373

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

   374

			do {

   375

			#ifdef NDEBUG

   376

				LoadNextSprite(start, file_index);

   377

			#else

   378

				bool b = LoadNextSprite(start, file_index);

   379

				assert(b);

   380

			#endif

   381

			} while (++start <= end);

   382

		}

   383

	}

   384

}

   385

   386

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

   387

   388

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

   389

{

   390

	FILE *f;

   391

	fread_t *proc;

   392

	uint32 hdr;

   393

   394

	if (!_cache_sprites)

   395

		return false;

   396

   397

	if (read) {

   398

		f = fopen(filename, "rb");

   399

		proc = fread;

   400

   401

		if (f == NULL)

   402

			return false;

   403

   404

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

   405

		if (hdr != SPRITECACHE_ID) {

   406

			fclose(f);

   407

			return false;

   408

		}

   409

	} else {

   410

		f = fopen(filename, "wb");

   411

		proc = (fread_t*) fwrite;

   412

   413

		if (f == NULL)

   414

			return false;

   415

   416

		hdr = SPRITECACHE_ID;

   417

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

   418

	}

   419

   420

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

   421

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

   422

   423

#if 0

   424

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

   425

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

   426

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

   427

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

   428

#endif

   429

   430

#if !defined(WANT_NEW_LRU)

   431

	if (read)

   432

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

   433

#endif

   434

   435

	fclose(f);

   436

	return true;

   437

}

   438

   439

#define S_FREE_MASK 1

   440

   441

static inline MemBlock* NextBlock(MemBlock* block)

   442

{

   443

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

   444

}

   445

   446

static uint32 GetSpriteCacheUsage(void)

   447

{

   448

	size_t tot_size = 0;

   449

	MemBlock* s;

   450

   451

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

   452

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

   453

   454

	return tot_size;

   455

}

   456

   457

   458

void IncreaseSpriteLRU(void)

   459

{

   460

	int i;

   461

   462

	// Increase all LRU values

   463

#if defined(WANT_NEW_LRU)

   464

	if (_sprite_lru_counter > 16384) {

   465

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

   466

   467

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

   468

			if (_sprite_ptr[i] != NULL) {

   469

				if (_sprite_lru_new[i] >= 0) {

   470

					_sprite_lru_new[i] = -1;

   471

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

   472

					_sprite_lru_new[i]--;

   473

				}

   474

			}

   475

		_sprite_lru_counter = 0;

   476

	}

   477

#else

   478

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

   479

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

   480

			_sprite_lru[i]++;

   481

	// Reset the lru counter.

   482

	_sprite_lru_counter = 0;

   483

#endif

   484

   485

	// Compact sprite cache every now and then.

   486

	if (++_compact_cache_counter >= 740) {

   487

		CompactSpriteCache();

   488

		_compact_cache_counter = 0;

   489

	}

   490

}

   491

   492

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

   493

// That is accomplished by moving the cached data.

   494

static void CompactSpriteCache(void)

   495

{

   496

	MemBlock *s;

   497

   498

	DEBUG(spritecache, 2) (

   499

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

   500

	);