1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "fileio.h"

     5

#include "newgrf.h"

     6

#include "md5.h"

     7

#include <ctype.h>

     8

     9

#define SPRITECACHE_ID 0xF00F0006

    10

#define SPRITE_CACHE_SIZE 1024*1024

    11

    12

    13

//#define WANT_SPRITESIZES

    14

#define WANT_NEW_LRU

    15

//#define WANT_LOCKED

    16

    17

    18

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

    19

    20

int _skip_sprites = 0;

    21

int _replace_sprites_count[16];

    22

int _replace_sprites_offset[16];

    23

    24

static const char *_cur_grffile;

    25

static int _loading_stage;

    26

static int _skip_specials;

    27

uint16 _custom_sprites_base;

    28

static SpriteHdr _cur_sprite;

    29

    30

    31

static byte *_sprite_ptr[NUM_SPRITES];

    32

static uint16 _sprite_size[NUM_SPRITES];

    33

static uint32 _sprite_file_pos[NUM_SPRITES];

    34

    35

// This one is probably not needed.

    36

#if defined(WANT_LOCKED)

    37

static bool _sprite_locked[NUM_SPRITES];

    38

#endif

    39

    40

#if defined(WANT_NEW_LRU)

    41

static int16 _sprite_lru_new[NUM_SPRITES];

    42

#else

    43

static uint16 _sprite_lru[NUM_SPRITES];

    44

static uint16 _sprite_lru_cur[NUM_SPRITES];

    45

#endif

    46

    47

#ifdef WANT_SPRITESIZES

    48

static int8 _sprite_xoffs[NUM_SPRITES];

    49

static int8 _sprite_yoffs[NUM_SPRITES];

    50

static uint16 _sprite_xsize[NUM_SPRITES];

    51

static uint8 _sprite_ysize[NUM_SPRITES];

    52

#endif

    53

    54

static uint _sprite_lru_counter;

    55

static byte *_spritecache_ptr;

    56

static uint32 _spritecache_size;

    57

static int _compact_cache_counter;

    58

    59

typedef struct MD5File {

    60

	const char * const filename;     // filename

    61

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

    62

} MD5File;

    63

    64

typedef struct FileList {

    65

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

    66

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

    67

} FileList;

    68

    69

#include "table/files.h"

    70

#include "table/landscape_sprite.h"

    71

    72

static const uint16 * const _landscape_spriteindexes[] = {

    73

	_landscape_spriteindexes_1,

    74

	_landscape_spriteindexes_2,

    75

	_landscape_spriteindexes_3,

    76

};

    77

    78

static const uint16 * const _slopes_spriteindexes[] = {

    79

	_slopes_spriteindexes_0,

    80

	_slopes_spriteindexes_1,

    81

	_slopes_spriteindexes_2,

    82

	_slopes_spriteindexes_3,

    83

};

    84

    85

static void CompactSpriteCache(void);

    86

    87

static void ReadSpriteHeaderSkipData(int num, int load_index)

    88

{

    89

	byte type;

    90

	int8 i;

    91

	int deaf = 0;

    92

    93

	if (_skip_sprites) {

    94

		if (_skip_sprites > 0)

    95

			_skip_sprites--;

    96

		deaf = 1;

    97

	}

    98

    99

	type = FioReadByte();

   100

	_cur_sprite.info = type;

   101

	if (type == 0xFF) {

   102

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

   103

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

   104

		 * because if no special sprite referencing to them is

   105

		 * processed, they themselves are never referenced and loaded

   106

		 * on their own. */

   107

		if (_skip_specials || deaf) {

   108

			FioSkipBytes(num);

   109

		} else {

   110

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   111

		}

   112

		return;

   113

	}

   114

   115

#ifdef WANT_SPRITESIZES

   116

	_cur_sprite.height = FioReadByte();

   117

	_cur_sprite.width = FioReadWord();

   118

	_cur_sprite.x_offs = FioReadWord();

   119

	_cur_sprite.y_offs = FioReadWord();

   120

#else

   121

	FioSkipBytes(7);

   122

#endif

   123

	num -= 8;

   124

	if (num == 0)

   125

		return;

   126

   127

	if (type & 2) {

   128

		FioSkipBytes(num);

   129

		return;

   130

	}

   131

   132

	while (num) {

   133

		i = FioReadByte();

   134

		if (i>=0) {

   135

			num -= i;

   136

			FioSkipBytes(i);

   137

		} else {

   138

			i = -(i >> 3);

   139

			num -= i;

   140

			FioReadByte();

   141

		}

   142

	}

   143

}

   144

   145

static void ReadSprite(int num, byte *dest)

   146

{

   147

	byte type;

   148

	byte *rel;

   149

	int8 i;

   150

	int j, dist;

   151

   152

	type = FioReadByte();

   153

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

   154

	if (type != 0xFF) {

   155

		/* read sprite hdr */

   156

		*dest++ = type;

   157

		for(j=0; j!=7; j++)

   158

			*dest++ = FioReadByte();

   159

		num -= 8;

   160

	}

   161

   162

	if (type & 2) {

   163

		while (num--)

   164

			*dest++ = FioReadByte();

   165

		return;

   166

	}

   167

   168

	while (num) {

   169

		i = FioReadByte();

   170

		if (i>=0) {

   171

			num -= i;

   172

			while (i--)

   173

				*dest++ = FioReadByte();

   174

		} else {

   175

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

   176

			i = -(i >> 3);

   177

			num -= i;

   178

   179

			rel = &dest[dist];

   180

			while (i--)

   181

				*dest++ = *rel++;

   182

		}

   183

	}

   184

}

   185

   186

   187

static bool LoadNextSprite(int load_index, byte file_index)

   188

{

   189

	uint16 size;

   190

	uint32 file_pos;

   191

   192

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

   193

		return false;

   194

   195

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

   196

   197

	ReadSpriteHeaderSkipData(size, load_index);

   198

   199

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

   200

		int count = _replace_sprites_count[0];

   201

		int offset = _replace_sprites_offset[0];

   202

   203

		_replace_sprites_offset[0]++;

   204

		_replace_sprites_count[0]--;

   205

   206

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

   207

			load_index = offset;

   208

		} else {

   209

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

   210

					count, offset);

   211

			_replace_sprites_offset[0] = 0;

   212

			_replace_sprites_count[0] = 0;

   213

		}

   214

   215

		if (_replace_sprites_count[0] == 0) {

   216

			int i;

   217

   218

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

   219

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

   220

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

   221

			}

   222

			_replace_sprites_count[i] = 0;

   223

			_replace_sprites_offset[i] = 0;

   224

		}

   225

	}

   226

   227

	_sprite_size[load_index] = size;

   228

	_sprite_file_pos[load_index] = file_pos;

   229

   230

#ifdef WANT_SPRITESIZES

   231

	_sprite_xsize[load_index] = _cur_sprite.width;

   232

	_sprite_ysize[load_index] = _cur_sprite.height;

   233

   234

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   235

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   236

#endif

   237

   238

	_sprite_ptr[load_index] = NULL;

   239

#if defined(WANT_LOCKED)

   240

	_sprite_locked[load_index] = false;

   241

#endif

   242

   243

#if defined(WANT_NEW_LRU)

   244

	_sprite_lru_new[load_index] = 0;

   245

#else

   246

	_sprite_lru[load_index] = 0xFFFF;

   247

	_sprite_lru_cur[load_index] = 0;

   248

#endif

   249

   250

	return true;

   251

}

   252

   253

static void SkipSprites(int count)

   254

{

   255

	while(count>0)

   256

	{

   257

		uint16 size;

   258

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

   259

			return;

   260

   261

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   262

		count--;

   263

	}

   264

}

   265

   266

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

   267

{

   268

	int load_index_org = load_index;

   269

   270

	FioOpenFile(file_index, filename);

   271

   272

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

   273

	 * might contain some special sprites. */

   274

	_skip_specials = 1;

   275

	_skip_sprites = 0;

   276

   277

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

   278

   279

	while (LoadNextSprite(load_index, file_index)) {

   280

		load_index++;

   281

		if (load_index >= NUM_SPRITES) {

   282

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

   283

		}

   284

	}

   285

   286

	return load_index - load_index_org;

   287

}

   288

   289

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

   290

{

   291

	int i;

   292

   293

	FioOpenFile(file_index, filename);

   294

	_cur_grffile = filename;

   295

	_skip_specials = 0;

   296

	_skip_sprites = 0;

   297

   298

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

   299

			filename, load_index);

   300

   301

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

   302

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

   303

	 * neither, apparently. */

   304

	{

   305

		int length;

   306

		byte type;

   307

   308

		length = FioReadWord();

   309

		type = FioReadByte();

   310

   311

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

   312

			FioReadDword();

   313

		} else {

   314

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

   315

		}

   316

	}

   317

   318

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

   319

		if (load_index + i >= NUM_SPRITES)

   320

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

   321

			      load_index + i);

   322

	}

   323

   324

	/* Clean up. */

   325

	_skip_sprites = 0;

   326

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

   327

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

   328

   329

	return i;

   330

}

   331

   332

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

   333

{

   334

	int start;

   335

   336

	FioOpenFile(file_index, filename);

   337

	_skip_specials = 1;

   338

	_skip_sprites = 0;

   339

   340

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

   341

   342

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

   343

		int end = *index_tbl++;

   344

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

   345

			SkipSprites(end);

   346

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

   347

			do {

   348

				bool b = LoadNextSprite(start, file_index);

   349

				assert(b);

   350

			} while (++start <= end);

   351

		}

   352

	}

   353

}

   354

   355

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

   356

   357

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

   358

{

   359

	FILE *f;

   360

	fread_t *proc;

   361

	uint32 hdr;

   362

   363

	if (!_cache_sprites)

   364

		return false;

   365

   366

	if (read) {

   367

		f = fopen(filename, "rb");

   368

		proc = fread;

   369

   370

		if (f == NULL)

   371

			return false;

   372

   373

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

   374

		if (hdr != SPRITECACHE_ID) {

   375

			fclose(f);

   376

			return false;

   377

		}

   378

	} else {

   379

		f = fopen(filename, "wb");

   380

		proc = (fread_t*) fwrite;

   381

   382

		if (f == NULL)

   383

			return false;

   384

   385

		hdr = SPRITECACHE_ID;

   386

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

   387

	}

   388

   389

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

   390

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

   391

   392

#if 0

   393

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

   394

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

   395

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

   396

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

   397

#endif

   398

   399

#if !defined(WANT_NEW_LRU)

   400

	if (read)

   401

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

   402

#endif

   403

   404

	fclose(f);

   405

	return true;

   406

}

   407

   408

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

   409

#define S_FREE_MASK 1

   410

#define S_HDRSIZE sizeof(uint32)

   411

   412

static uint32 GetSpriteCacheUsage(void)

   413

{

   414

	byte *s = _spritecache_ptr;

   415

	size_t cur_size, tot_size = 0;

   416

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

   417

		if ( cur_size & S_FREE_MASK ) {

   418

			cur_size--;

   419

		} else {

   420

			tot_size += cur_size;

   421

		}

   422

	}

   423

   424

	return tot_size;

   425

}

   426

   427

   428

void IncreaseSpriteLRU(void)

   429

{

   430

	int i;

   431

   432

	// Increase all LRU values

   433

#if defined(WANT_NEW_LRU)

   434

	if (_sprite_lru_counter > 16384) {

   435

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

   436

   437

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

   438

			if (_sprite_ptr[i] != NULL) {

   439

				if (_sprite_lru_new[i] >= 0) {

   440

					_sprite_lru_new[i] = -1;

   441

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

   442

					_sprite_lru_new[i]--;

   443

				}

   444

			}

   445

		_sprite_lru_counter = 0;

   446

	}

   447

#else

   448

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

   449

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

   450

			_sprite_lru[i]++;

   451

	// Reset the lru counter.

   452

	_sprite_lru_counter = 0;

   453

#endif

   454

   455

	// Compact sprite cache every now and then.

   456

	if (++_compact_cache_counter >= 740) {

   457

		CompactSpriteCache();

   458

		_compact_cache_counter = 0;

   459

	}

   460

}

   461

   462

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

   463

// That is accomplished by moving the cached data.

   464

static void CompactSpriteCache(void)

   465

{

   466

	byte *s, *t;

   467

	size_t size, sizeb, cur_size;

   468

	int i;

   469

   470

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

   471

   472

	s = _spritecache_ptr;

   473

   474

	while (true) {

   475

		size = S_DATA(s);

   476

   477

		// Only look for free blocks.

   478

		if (size & S_FREE_MASK) {

   479

			size -= S_FREE_MASK;

   480

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

   481

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

   482

   483

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

   484

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

   485

				break;

   486

   487

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

   488

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

   489

   490

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

   491

#if defined(WANT_LOCKED)

   492

			if (!_sprite_locked[i]) {

   493

#endif

   494

   495

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

   496

				_sprite_ptr[i] -= size;

   497

   498

				// Move the memory

   499

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

   500

   501

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

   502

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

   503

				S_DATA(s) = sizeb;

   504

   505

				// Then coalesce the free ones that follow.

   506

				s += sizeb;

   507

				while ((cur_size = S_DATA(s+size)) & S_FREE_MASK)

   508

					size += cur_size - S_FREE_MASK;

   509

				S_DATA(s) = size + S_FREE_MASK;

   510

				continue;

   511

#if defined(WANT_LOCKED)

   512

			}