1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "gfx.h"

     5

#include "fileio.h"

     6

#include "newgrf.h"

     7

#include "md5.h"

     8

#include <ctype.h>

     9

    10

#define SPRITECACHE_ID 0xF00F0006

    11

#define SPRITE_CACHE_SIZE 1024*1024

    12

    13

    14

//#define WANT_SPRITESIZES

    15

#define WANT_NEW_LRU

    16

//#define WANT_LOCKED

    17

    18

    19

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

    20

    21

int _skip_sprites = 0;

    22

int _replace_sprites_count[16];

    23

int _replace_sprites_offset[16];

    24

    25

static const char *_cur_grffile;

    26

static int _loading_stage;

    27

static int _skip_specials;

    28

uint16 _custom_sprites_base;

    29

static SpriteHdr _cur_sprite;

    30

    31

    32

static byte *_sprite_ptr[NUM_SPRITES];

    33

static uint16 _sprite_size[NUM_SPRITES];

    34

static uint32 _sprite_file_pos[NUM_SPRITES];

    35

    36

// This one is probably not needed.

    37

#if defined(WANT_LOCKED)

    38

static bool _sprite_locked[NUM_SPRITES];

    39

#endif

    40

    41

#if defined(WANT_NEW_LRU)

    42

static int16 _sprite_lru_new[NUM_SPRITES];

    43

#else

    44

static uint16 _sprite_lru[NUM_SPRITES];

    45

static uint16 _sprite_lru_cur[NUM_SPRITES];

    46

#endif

    47

    48

#ifdef WANT_SPRITESIZES

    49

static int8 _sprite_xoffs[NUM_SPRITES];

    50

static int8 _sprite_yoffs[NUM_SPRITES];

    51

static uint16 _sprite_xsize[NUM_SPRITES];

    52

static uint8 _sprite_ysize[NUM_SPRITES];

    53

#endif

    54

    55

static uint _sprite_lru_counter;

    56

static byte *_spritecache_ptr;

    57

static uint32 _spritecache_size;

    58

static int _compact_cache_counter;

    59

    60

typedef struct MD5File {

    61

	const char * const filename;     // filename

    62

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

    63

} MD5File;

    64

    65

typedef struct FileList {

    66

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

    67

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

    68

} FileList;

    69

    70

#include "table/files.h"

    71

#include "table/landscape_sprite.h"

    72

    73

static const uint16 * const _landscape_spriteindexes[] = {

    74

	_landscape_spriteindexes_1,

    75

	_landscape_spriteindexes_2,

    76

	_landscape_spriteindexes_3,

    77

};

    78

    79

static const uint16 * const _slopes_spriteindexes[] = {

    80

	_slopes_spriteindexes_0,

    81

	_slopes_spriteindexes_1,

    82

	_slopes_spriteindexes_2,

    83

	_slopes_spriteindexes_3,

    84

};

    85

    86

static void CompactSpriteCache(void);

    87

    88

static void ReadSpriteHeaderSkipData(int num, int load_index)

    89

{

    90

	byte type;

    91

	int8 i;

    92

	int deaf = 0;

    93

    94

	if (_skip_sprites) {

    95

		if (_skip_sprites > 0)

    96

			_skip_sprites--;

    97

		deaf = 1;

    98

	}

    99

   100

	type = FioReadByte();

   101

	_cur_sprite.info = type;

   102

	if (type == 0xFF) {

   103

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

   104

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

   105

		 * because if no special sprite referencing to them is

   106

		 * processed, they themselves are never referenced and loaded

   107

		 * on their own. */

   108

		if (_skip_specials || deaf) {

   109

			FioSkipBytes(num);

   110

		} else {

   111

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   112

		}

   113

		return;

   114

	}

   115

   116

#ifdef WANT_SPRITESIZES

   117

	_cur_sprite.height = FioReadByte();

   118

	_cur_sprite.width = FioReadWord();

   119

	_cur_sprite.x_offs = FioReadWord();

   120

	_cur_sprite.y_offs = FioReadWord();

   121

#else

   122

	FioSkipBytes(7);

   123

#endif

   124

	num -= 8;

   125

	if (num == 0)

   126

		return;

   127

   128

	if (type & 2) {

   129

		FioSkipBytes(num);

   130

		return;

   131

	}

   132

   133

	while (num) {

   134

		i = FioReadByte();

   135

		if (i>=0) {

   136

			num -= i;

   137

			FioSkipBytes(i);

   138

		} else {

   139

			i = -(i >> 3);

   140

			num -= i;

   141

			FioReadByte();

   142

		}

   143

	}

   144

}

   145

   146

static void ReadSprite(int num, byte *dest)

   147

{

   148

	byte type;

   149

	byte *rel;

   150

	int8 i;

   151

	int j, dist;

   152

   153

	type = FioReadByte();

   154

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

   155

	if (type != 0xFF) {

   156

		/* read sprite hdr */

   157

		*dest++ = type;

   158

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

   159

			*dest++ = FioReadByte();

   160

		num -= 8;

   161

	}

   162

   163

	if (type & 2) {

   164

		while (num--)

   165

			*dest++ = FioReadByte();

   166

		return;

   167

	}

   168

   169

	while (num) {

   170

		i = FioReadByte();

   171

		if (i>=0) {

   172

			num -= i;

   173

			while (i--)

   174

				*dest++ = FioReadByte();

   175

		} else {

   176

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

   177

			i = -(i >> 3);

   178

			num -= i;

   179

   180

			rel = &dest[dist];

   181

			while (i--)

   182

				*dest++ = *rel++;

   183

		}

   184

	}

   185

}

   186

   187

   188

static bool LoadNextSprite(int load_index, byte file_index)

   189

{

   190

	uint16 size;

   191

	uint32 file_pos;

   192

   193

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

   194

		return false;

   195

   196

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

   197

   198

	ReadSpriteHeaderSkipData(size, load_index);

   199

   200

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

   201

		int count = _replace_sprites_count[0];

   202

		int offset = _replace_sprites_offset[0];

   203

   204

		_replace_sprites_offset[0]++;

   205

		_replace_sprites_count[0]--;

   206

   207

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

   208

			load_index = offset;

   209

		} else {

   210

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

   211

					count, offset);

   212

			_replace_sprites_offset[0] = 0;

   213

			_replace_sprites_count[0] = 0;

   214

		}

   215

   216

		if (_replace_sprites_count[0] == 0) {

   217

			int i;

   218

   219

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

   220

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

   221

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

   222

			}

   223

			_replace_sprites_count[i] = 0;

   224

			_replace_sprites_offset[i] = 0;

   225

		}

   226

	}

   227

   228

	_sprite_size[load_index] = size;

   229

	_sprite_file_pos[load_index] = file_pos;

   230

   231

#ifdef WANT_SPRITESIZES

   232

	_sprite_xsize[load_index] = _cur_sprite.width;

   233

	_sprite_ysize[load_index] = _cur_sprite.height;

   234

   235

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   236

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   237

#endif

   238

   239

	_sprite_ptr[load_index] = NULL;

   240

#if defined(WANT_LOCKED)

   241

	_sprite_locked[load_index] = false;

   242

#endif

   243

   244

#if defined(WANT_NEW_LRU)

   245

	_sprite_lru_new[load_index] = 0;

   246

#else

   247

	_sprite_lru[load_index] = 0xFFFF;

   248

	_sprite_lru_cur[load_index] = 0;

   249

#endif

   250

   251

	return true;

   252

}

   253

   254

static void SkipSprites(int count)

   255

{

   256

	while(count>0)

   257

	{

   258

		uint16 size;

   259

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

   260

			return;

   261

   262

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   263

		count--;

   264

	}

   265

}

   266

   267

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

   268

{

   269

	int load_index_org = load_index;

   270

   271

	FioOpenFile(file_index, filename);

   272

   273

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

   274

	 * might contain some special sprites. */

   275

	_skip_specials = 1;

   276

	_skip_sprites = 0;

   277

   278

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

   279

   280

	while (LoadNextSprite(load_index, file_index)) {

   281

		load_index++;

   282

		if (load_index >= NUM_SPRITES) {

   283

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

   284

		}

   285

	}

   286

   287

	return load_index - load_index_org;

   288

}

   289

   290

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

   291

{

   292

	int i;

   293

   294

	FioOpenFile(file_index, filename);

   295

	_cur_grffile = filename;

   296

	_skip_specials = 0;

   297

	_skip_sprites = 0;

   298

   299

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

   300

			filename, load_index);

   301

   302

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

   303

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

   304

	 * neither, apparently. */

   305

	{

   306

		int length;

   307

		byte type;

   308

   309

		length = FioReadWord();

   310

		type = FioReadByte();

   311

   312

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

   313

			FioReadDword();

   314

		} else {

   315

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

   316

		}

   317

	}

   318

   319

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

   320

		if (load_index + i >= NUM_SPRITES)

   321

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

   322

			      load_index + i);

   323

	}

   324

   325

	/* Clean up. */

   326

	_skip_sprites = 0;

   327

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

   328

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

   329

   330

	return i;

   331

}

   332

   333

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

   334

{

   335

	int start;

   336

   337

	FioOpenFile(file_index, filename);

   338

	_skip_specials = 1;

   339

	_skip_sprites = 0;

   340

   341

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

   342

   343

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

   344

		int end = *index_tbl++;

   345

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

   346

			SkipSprites(end);

   347

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

   348

			do {

   349

				bool b = LoadNextSprite(start, file_index);

   350

				assert(b);

   351

			} while (++start <= end);

   352

		}

   353

	}

   354

}

   355

   356

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

   357

   358

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

   359

{

   360

	FILE *f;

   361

	fread_t *proc;

   362

	uint32 hdr;

   363

   364

	if (!_cache_sprites)

   365

		return false;

   366

   367

	if (read) {

   368

		f = fopen(filename, "rb");

   369

		proc = fread;

   370

   371

		if (f == NULL)

   372

			return false;

   373

   374

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

   375

		if (hdr != SPRITECACHE_ID) {

   376

			fclose(f);

   377

			return false;

   378

		}

   379

	} else {

   380

		f = fopen(filename, "wb");

   381

		proc = (fread_t*) fwrite;

   382

   383

		if (f == NULL)

   384

			return false;

   385

   386

		hdr = SPRITECACHE_ID;

   387

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

   388

	}

   389

   390

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

   391

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

   392

   393

#if 0

   394

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

   395

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

   396

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

   397

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

   398

#endif

   399

   400

#if !defined(WANT_NEW_LRU)

   401

	if (read)

   402

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

   403

#endif

   404

   405

	fclose(f);

   406

	return true;

   407

}

   408

   409

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

   410

#define S_FREE_MASK 1

   411

#define S_HDRSIZE sizeof(uint32)

   412

   413

static uint32 GetSpriteCacheUsage(void)

   414

{

   415

	byte *s = _spritecache_ptr;

   416

	size_t cur_size, tot_size = 0;

   417

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

   418

		if ( cur_size & S_FREE_MASK ) {

   419

			cur_size--;

   420

		} else {

   421

			tot_size += cur_size;

   422

		}

   423

	}

   424

   425

	return tot_size;

   426

}

   427

   428

   429

void IncreaseSpriteLRU(void)

   430

{

   431

	int i;

   432

   433

	// Increase all LRU values

   434

#if defined(WANT_NEW_LRU)

   435

	if (_sprite_lru_counter > 16384) {

   436

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

   437

   438

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

   439

			if (_sprite_ptr[i] != NULL) {

   440

				if (_sprite_lru_new[i] >= 0) {

   441

					_sprite_lru_new[i] = -1;

   442

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

   443

					_sprite_lru_new[i]--;

   444

				}

   445

			}

   446

		_sprite_lru_counter = 0;

   447

	}

   448

#else

   449

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

   450

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

   451

			_sprite_lru[i]++;

   452

	// Reset the lru counter.

   453

	_sprite_lru_counter = 0;

   454

#endif

   455

   456

	// Compact sprite cache every now and then.

   457

	if (++_compact_cache_counter >= 740) {

   458

		CompactSpriteCache();

   459

		_compact_cache_counter = 0;

   460

	}

   461

}

   462

   463

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

   464

// That is accomplished by moving the cached data.

   465

static void CompactSpriteCache(void)

   466

{

   467

	byte *s, *t;

   468

	size_t size, sizeb, cur_size;

   469

	int i;

   470

   471

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

   472

   473

	s = _spritecache_ptr;

   474

   475

	while (true) {

   476

		size = S_DATA(s);

   477

   478

		// Only look for free blocks.

   479

		if (size & S_FREE_MASK) {

   480

			size -= S_FREE_MASK;

   481

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

   482

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

   483

   484

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

   485

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

   486

				break;

   487

   488

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

   489

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

   490

   491

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

   492

#if defined(WANT_LOCKED)

   493

			if (!_sprite_locked[i]) {

   494

#endif

   495

   496

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

   497

				_sprite_ptr[i] -= size;

   498

   499

				// Move the memory

   500

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

   501

   502

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

   503

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

   504

				S_DATA(s) = sizeb;

   505

   506

				// Then coalesce the free ones that follow.

   507

				s += sizeb;

   508

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

   509

					size += cur_size - S_FREE_MASK;

   510

				S_DATA(s) = size + S_FREE_MASK;

   511

				continue;

   512

#if defined(WANT_LOCKED)