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

    56

static uint _sprite_lru_counter;

    57

static byte *_spritecache_ptr;

    58

static uint32 _spritecache_size;

    59

static int _compact_cache_counter;

    60

    61

typedef struct MD5File {

    62

	const char * const filename;     // filename

    63

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

    64

} MD5File;

    65

    66

typedef struct FileList {

    67

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

    68

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

    69

} FileList;

    70

    71

#include "table/files.h"

    72

#include "table/landscape_sprite.h"

    73

    74

static const uint16 * const _landscape_spriteindexes[] = {

    75

	_landscape_spriteindexes_1,

    76

	_landscape_spriteindexes_2,

    77

	_landscape_spriteindexes_3,

    78

};

    79

    80

static const uint16 * const _slopes_spriteindexes[] = {

    81

	_slopes_spriteindexes_0,

    82

	_slopes_spriteindexes_1,

    83

	_slopes_spriteindexes_2,

    84

	_slopes_spriteindexes_3,

    85

};

    86

    87

static void CompactSpriteCache(void);

    88

    89

static void ReadSpriteHeaderSkipData(int num, int load_index)

    90

{

    91

	byte type;

    92

	int8 i;

    93

	int deaf = 0;

    94

    95

	if (_skip_sprites) {

    96

		if (_skip_sprites > 0)

    97

			_skip_sprites--;

    98

		deaf = 1;

    99

	}

   100

   101

	type = FioReadByte();

   102

	_cur_sprite.info = type;

   103

	if (type == 0xFF) {

   104

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

   105

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

   106

		 * because if no special sprite referencing to them is

   107

		 * processed, they themselves are never referenced and loaded

   108

		 * on their own. */

   109

		if (_skip_specials || deaf) {

   110

			FioSkipBytes(num);

   111

		} else {

   112

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   113

		}

   114

		return;

   115

	}

   116

   117

#ifdef WANT_SPRITESIZES

   118

	_cur_sprite.height = FioReadByte();

   119

	_cur_sprite.width = FioReadWord();

   120

	_cur_sprite.x_offs = FioReadWord();

   121

	_cur_sprite.y_offs = FioReadWord();

   122

#else

   123

	FioSkipBytes(7);

   124

#endif

   125

	num -= 8;

   126

	if (num == 0)

   127

		return;

   128

   129

	if (type & 2) {

   130

		FioSkipBytes(num);

   131

		return;

   132

	}

   133

   134

	while (num) {

   135

		i = FioReadByte();

   136

		if (i>=0) {

   137

			num -= i;

   138

			FioSkipBytes(i);

   139

		} else {

   140

			i = -(i >> 3);

   141

			num -= i;

   142

			FioReadByte();

   143

		}

   144

	}

   145

}

   146

   147

static void ReadSprite(int num, byte *dest)

   148

{

   149

	byte type;

   150

	byte *rel;

   151

	int8 i;

   152

	int dist;

   153

   154

	type = FioReadByte();

   155

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

   156

	if (type != 0xFF) {

   157

		/* read sprite hdr */

   158

		Sprite* sprite = dest;

   159

		sprite->info = type;

   160

		sprite->height = FioReadByte();

   161

		sprite->width = FioReadWord();

   162

		sprite->x_offs = FioReadWord();

   163

		sprite->y_offs = FioReadWord();

   164

		dest = sprite->data;

   165

		num -= 8;

   166

	}

   167

   168

	if (type & 2) {

   169

		while (num--)

   170

			*dest++ = FioReadByte();

   171

		return;

   172

	}

   173

   174

	while (num) {

   175

		i = FioReadByte();

   176

		if (i>=0) {

   177

			num -= i;

   178

			while (i--)

   179

				*dest++ = FioReadByte();

   180

		} else {

   181

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

   182

			i = -(i >> 3);

   183

			num -= i;

   184

   185

			rel = &dest[dist];

   186

			while (i--)

   187

				*dest++ = *rel++;

   188

		}

   189

	}

   190

}

   191

   192

   193

static bool LoadNextSprite(int load_index, byte file_index)

   194

{

   195

	uint16 size;

   196

	uint32 file_pos;

   197

   198

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

   199

		return false;

   200

   201

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

   202

   203

	ReadSpriteHeaderSkipData(size, load_index);

   204

   205

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

   206

		int count = _replace_sprites_count[0];

   207

		int offset = _replace_sprites_offset[0];

   208

   209

		_replace_sprites_offset[0]++;

   210

		_replace_sprites_count[0]--;

   211

   212

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

   213

			load_index = offset;

   214

		} else {

   215

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

   216

					count, offset);

   217

			_replace_sprites_offset[0] = 0;

   218

			_replace_sprites_count[0] = 0;

   219

		}

   220

   221

		if (_replace_sprites_count[0] == 0) {

   222

			int i;

   223

   224

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

   225

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

   226

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

   227

			}

   228

			_replace_sprites_count[i] = 0;

   229

			_replace_sprites_offset[i] = 0;

   230

		}

   231

	}

   232

   233

	_sprite_size[load_index] = size;

   234

	_sprite_file_pos[load_index] = file_pos;

   235

   236

#ifdef WANT_SPRITESIZES

   237

	_sprite_xsize[load_index] = _cur_sprite.width;

   238

	_sprite_ysize[load_index] = _cur_sprite.height;

   239

   240

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   241

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   242

#endif

   243

   244

	_sprite_ptr[load_index] = NULL;

   245

#if defined(WANT_LOCKED)

   246

	_sprite_locked[load_index] = false;

   247

#endif

   248

   249

#if defined(WANT_NEW_LRU)

   250

	_sprite_lru_new[load_index] = 0;

   251

#else

   252

	_sprite_lru[load_index] = 0xFFFF;

   253

	_sprite_lru_cur[load_index] = 0;

   254

#endif

   255

   256

	return true;

   257

}

   258

   259

static void SkipSprites(int count)

   260

{

   261

	while(count>0)

   262

	{

   263

		uint16 size;

   264

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

   265

			return;

   266

   267

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   268

		count--;

   269

	}

   270

}

   271

   272

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

   273

{

   274

	int load_index_org = load_index;

   275

   276

	FioOpenFile(file_index, filename);

   277

   278

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

   279

	 * might contain some special sprites. */

   280

	_skip_specials = 1;

   281

	_skip_sprites = 0;

   282

   283

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

   284

   285

	while (LoadNextSprite(load_index, file_index)) {

   286

		load_index++;

   287

		if (load_index >= NUM_SPRITES) {

   288

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

   289

		}

   290

	}

   291

   292

	return load_index - load_index_org;

   293

}

   294

   295

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

   296

{

   297

	int i;

   298

   299

	FioOpenFile(file_index, filename);

   300

	_cur_grffile = filename;

   301

	_skip_specials = 0;

   302

	_skip_sprites = 0;

   303

   304

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

   305

			filename, load_index);

   306

   307

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

   308

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

   309

	 * neither, apparently. */

   310

	{

   311

		int length;

   312

		byte type;

   313

   314

		length = FioReadWord();

   315

		type = FioReadByte();

   316

   317

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

   318

			FioReadDword();

   319

		} else {

   320

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

   321

		}

   322

	}

   323

   324

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

   325

		if (load_index + i >= NUM_SPRITES)

   326

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

   327

			      load_index + i);

   328

	}

   329

   330

	/* Clean up. */

   331

	_skip_sprites = 0;

   332

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

   333

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

   334

   335

	return i;

   336

}

   337

   338

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

   339

{

   340

	int start;

   341

   342

	FioOpenFile(file_index, filename);

   343

	_skip_specials = 1;

   344

	_skip_sprites = 0;

   345

   346

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

   347

   348

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

   349

		int end = *index_tbl++;

   350

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

   351

			SkipSprites(end);

   352

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

   353

			do {

   354

				bool b = LoadNextSprite(start, file_index);

   355

				assert(b);

   356

			} while (++start <= end);

   357

		}

   358

	}

   359

}

   360

   361

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

   362

   363

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

   364

{

   365

	FILE *f;

   366

	fread_t *proc;

   367

	uint32 hdr;

   368

   369

	if (!_cache_sprites)

   370

		return false;

   371

   372

	if (read) {

   373

		f = fopen(filename, "rb");

   374

		proc = fread;

   375

   376

		if (f == NULL)

   377

			return false;

   378

   379

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

   380

		if (hdr != SPRITECACHE_ID) {

   381

			fclose(f);

   382

			return false;

   383

		}

   384

	} else {

   385

		f = fopen(filename, "wb");

   386

		proc = (fread_t*) fwrite;

   387

   388

		if (f == NULL)

   389

			return false;

   390

   391

		hdr = SPRITECACHE_ID;

   392

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

   393

	}

   394

   395

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

   396

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

   397

   398

#if 0

   399

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

   400

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

   401

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

   402

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

   403

#endif

   404

   405

#if !defined(WANT_NEW_LRU)

   406

	if (read)

   407

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

   408

#endif

   409

   410

	fclose(f);

   411

	return true;

   412

}

   413

   414

#define S_DATA(x) (*(uint32*)(x))

   415

#define S_FREE_MASK 1

   416

#define S_HDRSIZE sizeof(uint32)

   417

   418

static uint32 GetSpriteCacheUsage(void)

   419

{

   420

	byte *s = _spritecache_ptr;

   421

	size_t cur_size, tot_size = 0;

   422

	for(; (cur_size=S_DATA(s)) != 0; s+=cur_size) {

   423

		if ( cur_size & S_FREE_MASK ) {

   424

			cur_size--;

   425

		} else {

   426

			tot_size += cur_size;

   427

		}

   428

	}

   429

   430

	return tot_size;

   431

}

   432

   433

   434

void IncreaseSpriteLRU(void)

   435

{

   436

	int i;

   437

   438

	// Increase all LRU values

   439

#if defined(WANT_NEW_LRU)

   440

	if (_sprite_lru_counter > 16384) {

   441

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

   442

   443

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

   444

			if (_sprite_ptr[i] != NULL) {

   445

				if (_sprite_lru_new[i] >= 0) {

   446

					_sprite_lru_new[i] = -1;

   447

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

   448

					_sprite_lru_new[i]--;

   449

				}

   450

			}

   451

		_sprite_lru_counter = 0;

   452

	}

   453

#else

   454

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

   455

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

   456

			_sprite_lru[i]++;

   457

	// Reset the lru counter.

   458

	_sprite_lru_counter = 0;

   459

#endif

   460

   461

	// Compact sprite cache every now and then.

   462

	if (++_compact_cache_counter >= 740) {

   463

		CompactSpriteCache();

   464

		_compact_cache_counter = 0;

   465

	}

   466

}

   467

   468

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

   469

// That is accomplished by moving the cached data.

   470

static void CompactSpriteCache(void)

   471

{

   472

	byte *s, *t;

   473

	size_t size, sizeb, cur_size;

   474

	int i;

   475

   476

	DEBUG(spritecache, 2) ("compacting sprite cache, inuse=%d", GetSpriteCacheUsage());

   477

   478

	s = _spritecache_ptr;

   479

   480

	while (true) {

   481

		size = S_DATA(s);

   482

   483

		// Only look for free blocks.

   484

		if (size & S_FREE_MASK) {

   485

			size -= S_FREE_MASK;

   486

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

   487

			assert(!(S_DATA(s+size) & S_FREE_MASK));

   488

   489

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

   490

			if ( (sizeb=S_DATA(s + size)) == 0)

   491

				break;

   492

   493

			// Locate the sprite number belonging to the next pointer.

   494

			for(i=0,t=s+size+S_HDRSIZE; _sprite_ptr[i] != t; i++) {assert(i < NUM_SPRITES);}

   495

   496

			// If it's locked, we must not move it.

   497

#if defined(WANT_LOCKED)

   498

			if (!_sprite_locked[i]) {

   499

#endif

   500

   501

				// Offset the sprite pointer by the size of the free block

   502

				_sprite_ptr[i] -= size;

   503

   504

				// Move the memory

   505

				memmove(s + S_HDRSIZE, s + S_HDRSIZE + size, sizeb - S_HDRSIZE);

   506

   507

				// What we just did had the effect of swapping the allocated block with the free block, so we need to update

   508

				//  the block pointers. First update the allocated one. It is in use.

   509

				S_DATA(s) = sizeb;

   510

   511

				// Then coalesce the free ones that follow.