1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "gfx.h"

     5

#include "spritecache.h"

     6

#include "fileio.h"

     7

#include "newgrf.h"

     8

#include "md5.h"

     9

#include <ctype.h>

    10

    11

#define SPRITECACHE_ID 0xF00F0006

    12

#define SPRITE_CACHE_SIZE 1024*1024

    13

    14

    15

//#define WANT_SPRITESIZES

    16

#define WANT_NEW_LRU

    17

//#define WANT_LOCKED

    18

    19

    20

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

    21

    22

int _skip_sprites = 0;

    23

int _replace_sprites_count[16];

    24

int _replace_sprites_offset[16];

    25

    26

static const char *_cur_grffile;

    27

static int _loading_stage;

    28

static int _skip_specials;

    29

uint16 _custom_sprites_base;

    30

static Sprite _cur_sprite;

    31

    32

    33

static byte *_sprite_ptr[NUM_SPRITES];

    34

static uint16 _sprite_size[NUM_SPRITES];

    35

static uint32 _sprite_file_pos[NUM_SPRITES];

    36

    37

// This one is probably not needed.

    38

#if defined(WANT_LOCKED)

    39

static bool _sprite_locked[NUM_SPRITES];

    40

#endif

    41

    42

#if defined(WANT_NEW_LRU)

    43

static int16 _sprite_lru_new[NUM_SPRITES];

    44

#else

    45

static uint16 _sprite_lru[NUM_SPRITES];

    46

static uint16 _sprite_lru_cur[NUM_SPRITES];

    47

#endif

    48

    49

#ifdef WANT_SPRITESIZES

    50

static int8 _sprite_xoffs[NUM_SPRITES];

    51

static int8 _sprite_yoffs[NUM_SPRITES];

    52

static uint16 _sprite_xsize[NUM_SPRITES];

    53

static uint8 _sprite_ysize[NUM_SPRITES];

    54

#endif

    55

    61

static uint _sprite_lru_counter;

    63

static uint32 _spritecache_size;

    64

static int _compact_cache_counter;

    65

    66

typedef struct MD5File {

    67

	const char * const filename;     // filename

    68

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

    69

} MD5File;

    70

    71

typedef struct FileList {

    72

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

    73

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

    74

} FileList;

    75

    76

#include "table/files.h"

    77

#include "table/landscape_sprite.h"

    78

    79

static const uint16 * const _landscape_spriteindexes[] = {

    80

	_landscape_spriteindexes_1,

    81

	_landscape_spriteindexes_2,

    82

	_landscape_spriteindexes_3,

    83

};

    84

    85

static const uint16 * const _slopes_spriteindexes[] = {

    86

	_slopes_spriteindexes_0,

    87

	_slopes_spriteindexes_1,

    88

	_slopes_spriteindexes_2,

    89

	_slopes_spriteindexes_3,

    90

};

    91

    92

static void CompactSpriteCache(void);

    93

    94

static void ReadSpriteHeaderSkipData(int num, int load_index)

    95

{

    96

	byte type;

    97

	int8 i;

    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

		return;

   137

	}

   138

   139

	while (num) {

   140

		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

static void ReadSprite(int num, byte *dest)

   153

{

   154

	byte type;

   155

	byte *rel;

   156

	int8 i;

   157

	int dist;

   158

   159

	type = FioReadByte();

   160

	/* We've decoded special sprites when reading headers. */

   161

	if (type != 0xFF) {

   162

		/* read sprite hdr */

   163

		Sprite* sprite = dest;

   164

		sprite->info = type;

   165

		sprite->height = FioReadByte();

   166

		sprite->width = FioReadWord();

   167

		sprite->x_offs = FioReadWord();

   168

		sprite->y_offs = FioReadWord();

   169

		dest = sprite->data;

   170

		num -= 8;

   171

	}

   172

   173

	if (type & 2) {

   174

		while (num--)

   175

			*dest++ = FioReadByte();

   176

		return;

   177

	}

   178

   179

	while (num) {

   180

		i = FioReadByte();

   181

		if (i>=0) {

   182

			num -= i;

   183

			while (i--)

   184

				*dest++ = FioReadByte();

   185

		} else {

   186

			dist = -(((i&7)<<8)|FioReadByte());

   187

			i = -(i >> 3);

   188

			num -= i;

   189

   190

			rel = &dest[dist];

   191

			while (i--)

   192

				*dest++ = *rel++;

   193

		}

   194

	}

   195

}

   196

   197

   198

static bool LoadNextSprite(int load_index, byte file_index)

   199

{

   200

	uint16 size;

   201

	uint32 file_pos;

   202

   203

	if ((size = FioReadWord()) == 0)

   204

		return false;

   205

   206

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

   207

   208

	ReadSpriteHeaderSkipData(size, load_index);

   209

   210

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

   211

		int count = _replace_sprites_count[0];

   212

		int offset = _replace_sprites_offset[0];

   213

   214

		_replace_sprites_offset[0]++;

   215

		_replace_sprites_count[0]--;

   216

   217

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

   218

			load_index = offset;

   219

		} else {

   220

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

   221

					count, offset);

   222

			_replace_sprites_offset[0] = 0;

   223

			_replace_sprites_count[0] = 0;

   224

		}

   225

   226

		if (_replace_sprites_count[0] == 0) {

   227

			int i;

   228

   229

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

   230

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

   231

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

   232

			}

   233

			_replace_sprites_count[i] = 0;

   234

			_replace_sprites_offset[i] = 0;

   235

		}

   236

	}

   237

   238

	_sprite_size[load_index] = size;

   239

	_sprite_file_pos[load_index] = file_pos;

   240

   241

#ifdef WANT_SPRITESIZES

   242

	_sprite_xsize[load_index] = _cur_sprite.width;

   243

	_sprite_ysize[load_index] = _cur_sprite.height;

   244

   245

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   246

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   247

#endif

   248

   249

	_sprite_ptr[load_index] = NULL;

   250

#if defined(WANT_LOCKED)

   251

	_sprite_locked[load_index] = false;

   252

#endif

   253

   254

#if defined(WANT_NEW_LRU)

   255

	_sprite_lru_new[load_index] = 0;

   256

#else

   257

	_sprite_lru[load_index] = 0xFFFF;

   258

	_sprite_lru_cur[load_index] = 0;

   259

#endif

   260

   261

	return true;

   262

}

   263

   264

static void SkipSprites(int count)

   265

{

   266

	while(count>0)

   267

	{

   268

		uint16 size;

   269

		if ( (size = FioReadWord()) == 0)

   270

			return;

   271

   272

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   273

		count--;

   274

	}

   275

}

   276

   277

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

   278

{

   279

	int load_index_org = load_index;

   280

   281

	FioOpenFile(file_index, filename);

   282

   283

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

   284

	 * might contain some special sprites. */

   285

	_skip_specials = 1;

   286

	_skip_sprites = 0;

   287

   288

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

   289

   290

	while (LoadNextSprite(load_index, file_index)) {

   291

		load_index++;

   292

		if (load_index >= NUM_SPRITES) {

   293

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

   294

		}

   295

	}

   296

   297

	return load_index - load_index_org;

   298

}

   299

   300

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

   301

{

   302

	int i;

   303

   304

	FioOpenFile(file_index, filename);

   305

	_cur_grffile = filename;

   306

	_skip_specials = 0;

   307

	_skip_sprites = 0;

   308

   309

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

   310

			filename, load_index);

   311

   312

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

   313

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

   314

	 * neither, apparently. */

   315

	{

   316

		int length;

   317

		byte type;

   318

   319

		length = FioReadWord();

   320

		type = FioReadByte();

   321

   322

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

   323

			FioReadDword();

   324

		} else {

   325

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

   326

		}

   327

	}

   328

   329

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

   330

		if (load_index + i >= NUM_SPRITES)

   331

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

   332

			      load_index + i);

   333

	}

   334

   335

	/* Clean up. */

   336

	_skip_sprites = 0;

   337

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

   338

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

   339

   340

	return i;

   341

}

   342

   343

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

   344

{

   345

	int start;

   346

   347

	FioOpenFile(file_index, filename);

   348

	_skip_specials = 1;

   349

	_skip_sprites = 0;

   350

   351

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

   352

   353

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

   354

		int end = *index_tbl++;

   355

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

   356

			SkipSprites(end);

   357

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

   358

			do {

   359

				bool b = LoadNextSprite(start, file_index);

   360

				assert(b);

   361

			} while (++start <= end);

   362

		}

   363

	}

   364

}

   365

   366

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

   367

   368

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

   369

{

   370

	FILE *f;

   371

	fread_t *proc;

   372

	uint32 hdr;

   373

   374

	if (!_cache_sprites)

   375

		return false;

   376

   377

	if (read) {

   378

		f = fopen(filename, "rb");

   379

		proc = fread;

   380

   381

		if (f == NULL)

   382

			return false;

   383

   384

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

   385

		if (hdr != SPRITECACHE_ID) {

   386

			fclose(f);

   387

			return false;

   388

		}

   389

	} else {

   390

		f = fopen(filename, "wb");

   391

		proc = (fread_t*) fwrite;

   392

   393

		if (f == NULL)

   394

			return false;

   395

   396

		hdr = SPRITECACHE_ID;

   397

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

   398

	}

   399

   400

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

   401

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

   402

   403

#if 0

   404

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

   405

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

   406

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

   407

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

   408

#endif

   409

   410

#if !defined(WANT_NEW_LRU)

   411

	if (read)

   412

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

   413

#endif

   414

   415

	fclose(f);

   416

	return true;

   417

}

   418

   419

#define S_FREE_MASK 1

   425

   426

static uint32 GetSpriteCacheUsage(void)

   427

{

   433

   434

	return tot_size;

   435

}

   436

   437

   438

void IncreaseSpriteLRU(void)

   439

{

   440

	int i;

   441

   442

	// Increase all LRU values

   443

#if defined(WANT_NEW_LRU)

   444

	if (_sprite_lru_counter > 16384) {

   445

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

   446

   447

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

   448

			if (_sprite_ptr[i] != NULL) {

   449

				if (_sprite_lru_new[i] >= 0) {

   450

					_sprite_lru_new[i] = -1;

   451

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

   452

					_sprite_lru_new[i]--;

   453

				}

   454

			}

   455

		_sprite_lru_counter = 0;

   456

	}

   457

#else

   458

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

   459

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

   460

			_sprite_lru[i]++;

   461

	// Reset the lru counter.

   462

	_sprite_lru_counter = 0;

   463

#endif

   464

   465

	// Compact sprite cache every now and then.

   466

	if (++_compact_cache_counter >= 740) {

   467

		CompactSpriteCache();

   468

		_compact_cache_counter = 0;

   469

	}

   470

}

   471

   472

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

   473

// That is accomplished by moving the cached data.

   474

static void CompactSpriteCache(void)

   475

{

   477

   481

   488

			// Since free blocks are automatically coalesced, this should hold true.

   490

   491

			// If the next block is the sentinel block, we can safely return

   493

				break;

   494

   499

   506