1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "viewport.h"

     5

#include "player.h"

     6

#include "gui.h"

     7

#include "screenshot.h"

     8

     9

// called by the ScreenShot proc to generate screenshot lines.

    10

typedef void ScreenshotCallback(void *userdata, byte *buf, uint y, uint pitch, uint n);

    11

typedef bool ScreenshotHandlerProc(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const byte *palette);

    12

    13

typedef struct {

    14

	const char *name;

    15

	const char *extension;

    16

	ScreenshotHandlerProc *proc;

    17

} ScreenshotFormat;

    18

    19

//************************************************

    20

//*** SCREENSHOT CODE FOR WINDOWS BITMAP (.BMP)

    21

//************************************************

    22

#if defined(_MSC_VER)

    23

#pragma pack(push, 1)

    24

#endif

    25

    26

typedef struct BitmapFileHeader {

    27

	uint16 type;

    28

	uint32 size;

    29

	uint32 reserved;

    30

	uint32 off_bits;

    31

} GCC_PACK BitmapFileHeader;

    32

assert_compile(sizeof(BitmapFileHeader) == 14);

    33

    34

#if defined(_MSC_VER)

    35

#pragma pack(pop)

    36

#endif

    37

    38

typedef struct BitmapInfoHeader {

    39

	uint32 size;

    40

	int32 width, height;

    41

	uint16 planes, bitcount;

    42

	uint32 compression, sizeimage, xpels, ypels, clrused, clrimp;

    43

} BitmapInfoHeader;

    44

assert_compile(sizeof(BitmapInfoHeader) == 40);

    45

    46

typedef struct RgbQuad {

    47

	byte blue, green, red, reserved;

    48

} RgbQuad;

    49

assert_compile(sizeof(RgbQuad) == 4);

    50

    51

// generic .BMP writer

    52

static bool MakeBmpImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const byte *palette)

    53

{

    54

	BitmapFileHeader bfh;

    55

	BitmapInfoHeader bih;

    56

	RgbQuad rq[256];

    57

	byte *buff;

    58

	FILE *f;

    59

	uint i, padw;

    60

	uint n, maxlines;

    61

    62

	// only implemented for 8bit images so far.

    63

	if (pixelformat != 8)

    64

		return false;

    65

    66

	f = fopen(name, "wb");

    67

	if (f == NULL) return false;

    68

    69

	// each scanline must be aligned on a 32bit boundary

    70

	padw = (w + 3) & ~3;

    71

    72

	// setup the file header

    73

	bfh.type = TO_LE16('MB');

    74

	bfh.size = TO_LE32(sizeof(bfh) + sizeof(bih) + sizeof(RgbQuad) * 256 + padw * h);

    75

	bfh.reserved = 0;

    76

	bfh.off_bits = TO_LE32(sizeof(bfh) + sizeof(bih) + sizeof(RgbQuad) * 256);

    77

    78

	// setup the info header

    79

	bih.size = TO_LE32(sizeof(BitmapInfoHeader));

    80

	bih.width = TO_LE32(w);

    81

	bih.height = TO_LE32(h);

    82

	bih.planes = TO_LE16(1);

    83

	bih.bitcount = TO_LE16(8);

    84

	bih.compression = 0;

    85

	bih.sizeimage = 0;

    86

	bih.xpels = 0;

    87

	bih.ypels = 0;

    88

	bih.clrused = 0;

    89

	bih.clrimp = 0;

    90

    91

	// convert the palette to the windows format

    92

	for (i = 0; i != 256; i++) {

    93

		rq[i].red = *palette++;

    94

		rq[i].green = *palette++;

    95

		rq[i].blue = *palette++;

    96

		rq[i].reserved = 0;

    97

	}

    98

    99

	// write file header and info header and palette

   100

	if (fwrite(&bfh, sizeof(bfh), 1, f) != 1) return false;

   101

	if (fwrite(&bih, sizeof(bih), 1, f) != 1) return false;

   102

	if (fwrite(rq, sizeof(rq), 1, f) != 1) return false;

   103

   104

	// use by default 64k temp memory

   105

	maxlines = clamp(65536 / padw, 16, 128);

   106

   107

	// now generate the bitmap bits

   108

	buff = malloc(padw * maxlines); // by default generate 128 lines at a time.

   109

	if (buff == NULL) {

   110

		fclose(f);

   111

		return false;

   112

	}

   113

	memset(buff, 0, padw * maxlines); // zero the buffer to have the padding bytes set to 0

   114

   115

	// start at the bottom, since bitmaps are stored bottom up.

   116

	do {

   117

		// determine # lines

   118

		n = min(h, maxlines);

   119

		h -= n;

   120

   121

		// render the pixels

   122

		callb(userdata, buff, h, padw, n);

   123

   124

		// write each line

   125

		while (n)

   126

			if (fwrite(buff + (--n) * padw, padw, 1, f) != 1) {

   127

				free(buff);

   128

				fclose(f);

   129

				return false;

   130

			}

   131

	} while (h != 0);

   132

   133

	free(buff);

   134

	fclose(f);

   135

   136

	return true;

   137

}

   138

   139

//********************************************************

   140

//*** SCREENSHOT CODE FOR PORTABLE NETWORK GRAPHICS (.PNG)

   141

//********************************************************

   142

#if defined(WITH_PNG)

   143

#include <png.h>

   144

   145

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   146

{

   147

	DEBUG(misc, 0) ("ERROR(libpng): %s - %s\n", message, (char *)png_get_error_ptr(png_ptr));

   148

	longjmp(png_ptr->jmpbuf, 1);

   149

}

   150

   151

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   152

{

   153

	DEBUG(misc, 0) ("WARNING(libpng): %s - %s\n", message, (char *)png_get_error_ptr(png_ptr));

   154

}

   155

   156

static bool MakePNGImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const byte *palette)

   157

{

   158

	png_color rq[256];

   159

	byte *buff;

   160

	FILE *f;

   161

	uint i, y, n;

   162

	uint maxlines;

   163

	png_structp png_ptr;

   164

	png_infop info_ptr;

   165

   166

	// only implemented for 8bit images so far.

   167

	if (pixelformat != 8)

   168

		return false;

   169

   170

	f = fopen(name, "wb");

   171

	if (f == NULL) return false;

   172

   173

	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (char *)name, png_my_error, png_my_warning);

   174

   175

	if (png_ptr == NULL) {

   176

		fclose(f);

   177

		return false;

   178

	}

   179

   180

	info_ptr = png_create_info_struct(png_ptr);

   181

	if (info_ptr == NULL) {

   182

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   183

		fclose(f);

   184

		return false;

   185

	}

   186

   187

	if (setjmp(png_jmpbuf(png_ptr))) {

   188

		png_destroy_write_struct(&png_ptr, &info_ptr);

   189

		fclose(f);

   190

		return false;

   191

	}

   192

   193

	png_init_io(png_ptr, f);

   194

   195

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   196

   197

	png_set_IHDR(png_ptr, info_ptr, w, h, pixelformat, PNG_COLOR_TYPE_PALETTE,

   198

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   199

   200

	// convert the palette to the .PNG format.

   201

	{

   202

    // avoids "might be clobbered" warning of argument "palette"

   203

		const byte *pal = palette;

   204

   205

		for (i = 0; i != 256; i++) {

   206

			rq[i].red = *pal++;

   207

			rq[i].green = *pal++;

   208

			rq[i].blue = *pal++;

   209

		}

   210

	}

   211

   212

	png_set_PLTE(png_ptr, info_ptr, rq, 256);

   213

	png_write_info(png_ptr, info_ptr);

   214

	png_set_flush(png_ptr, 512);

   215

   216

	// use by default 64k temp memory

   217

	maxlines = clamp(65536 / w, 16, 128);

   218

   219

	// now generate the bitmap bits

   220

	buff = malloc(w * maxlines); // by default generate 128 lines at a time.

   221

	if (buff == NULL) {

   222

		png_destroy_write_struct(&png_ptr, &info_ptr);

   223

		fclose(f);

   224

		return false;

   225

	}

   226

	memset(buff, 0, w * maxlines); // zero the buffer to have the padding bytes set to 0

   227

   228

	y = 0;

   229

	do {

   230

		// determine # lines to write

   231

		n = min(h - y, maxlines);

   232

   233

		// render the pixels into the buffer

   234

		callb(userdata, buff, y, w, n);

   235

		y += n;

   236

   237

		// write them to png

   238

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

   239

			png_write_row(png_ptr, buff + i * w);

   240

	} while (y != h);

   241

   242

	png_write_end(png_ptr, info_ptr);

   243

	png_destroy_write_struct(&png_ptr, &info_ptr);

   244

   245

	free(buff);

   246

	fclose(f);

   247

	return true;

   248

}

   249

#endif // WITH_PNG

   250

   251

   252

//************************************************

   253

//*** SCREENSHOT CODE FOR ZSOFT PAINTBRUSH (.PCX)

   254

//************************************************

   255

   256

typedef struct {

   257

	byte manufacturer;

   258

	byte version;

   259

	byte rle;

   260

	byte bpp;

   261

	uint32 unused;

   262

	uint16 xmax, ymax;

   263

	uint16 hdpi, vdpi;

   264

	byte pal_small[16*3];

   265

	byte reserved;

   266

	byte planes;

   267

	uint16 pitch;

   268

	uint16 cpal;

   269

	uint16 width;

   270

	uint16 height;

   271

	byte filler[54];

   272

} PcxHeader;

   273

assert_compile(sizeof(PcxHeader) == 128);

   274

   275

static bool MakePCXImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const byte *palette)

   276

{

   277

	byte *buff;

   278

	FILE *f;

   279

	uint maxlines;

   280

	uint y;

   281

	PcxHeader pcx;

   282

   283

	if (pixelformat != 8 || w == 0)

   284

		return false;

   285

   286

	f = fopen(name, "wb");

   287

	if (f == NULL) return false;

   288

   289

	memset(&pcx, 0, sizeof(pcx));

   290

   291

	// setup pcx header

   292

	pcx.manufacturer = 10;

   293

	pcx.version = 5;

   294

	pcx.rle = 1;

   295

	pcx.bpp = 8;

   296

	pcx.xmax = TO_LE16(w - 1);

   297

	pcx.ymax = TO_LE16(h - 1);

   298

	pcx.hdpi = TO_LE16(320);

   299

	pcx.vdpi = TO_LE16(320);

   300

   301

	pcx.planes = 1;

   302

	pcx.cpal = TO_LE16(1);

   303

	pcx.width = pcx.pitch = TO_LE16(w);

   304

	pcx.height = TO_LE16(h);

   305

   306

	// write pcx header

   307

	if (fwrite(&pcx, sizeof(pcx), 1, f) != 1) {

   308

		fclose(f);

   309

		return false;

   310

	}

   311

   312

	// use by default 64k temp memory

   313

	maxlines = clamp(65536 / w, 16, 128);

   314

   315

	// now generate the bitmap bits

   316

	buff = malloc(w * maxlines); // by default generate 128 lines at a time.

   317

	if (buff == NULL) {

   318

		fclose(f);

   319

		return false;

   320

	}

   321

	memset(buff, 0, w * maxlines); // zero the buffer to have the padding bytes set to 0

   322

   323

	y = 0;

   324

	do {

   325

		// determine # lines to write

   326

		uint n = min(h - y, maxlines);

   327

		uint i;

   328

   329

		// render the pixels into the buffer

   330

		callb(userdata, buff, y, w, n);

   331

		y += n;

   332

   333

		// write them to pcx

   334

		for (i = 0; i != n; i++) {

   335

			int runcount = 1;

   336

			byte *bufp = buff + i * w;

   337

			byte runchar = buff[0];

   338

			uint left;

   339

   340

			// for each pixel...

   341

			for (left = w - 1; left > 0; --left) {

   342

				byte ch = *bufp++;

   343

				if (ch != runchar || runcount >= 0x3f) {

   344

					if (runcount > 1 || (runchar & 0xC0) == 0xC0)

   345

						if (fputc(0xC0 | runcount, f) == EOF) {

   346

							free(buff);

   347

							fclose(f);

   348

							return false;

   349

						}

   350

					if (fputc(runchar, f) == EOF) {

   351

						free(buff);

   352

						fclose(f);

   353

						return false;

   354

					}

   355

					runcount = 0;

   356

					runchar = ch;

   357

				}

   358

				runcount++;

   359

			}

   360

   361

			// write remaining bytes..

   362

			if (runcount > 1 || (runchar & 0xC0) == 0xC0)

   363

				if (fputc(0xC0 | runcount, f) == EOF) {

   364

					free(buff);

   365

					fclose(f);

   366

					return false;

   367

				}

   368

			if (fputc(runchar, f) == EOF) {

   369

				free(buff);

   370

				fclose(f);

   371

				return false;

   372

			}

   373

		}

   374

	} while (y != h);

   375

   376

	free(buff);

   377

   378

	// write 8-bit color palette

   379

	if (fputc(12, f) == EOF) {

   380

		fclose(f);

   381

		return false;

   382

	}

   383

	if (fwrite(palette, 256 * 3, 1, f) != 1) {

   384

		fclose(f);

   385

		return false;

   386

	}

   387

	fclose(f);

   388

   389

	return true;

   390

}

   391

   392

//************************************************

   393

//*** GENERIC SCREENSHOT CODE

   394

//************************************************

   395

   396

static const ScreenshotFormat _screenshot_formats[] = {

   397

	{"BMP", "bmp", &MakeBmpImage},

   398

#if defined(WITH_PNG)

   399

	{"PNG", "png", &MakePNGImage},

   400

#endif

   401

	{"PCX", "pcx", &MakePCXImage},

   402

};

   403

   404

void InitializeScreenshotFormats(void)

   405

{

   406

	int i, j;

   407

	for (i = 0, j = 0; i != lengthof(_screenshot_formats); i++)

   408

		if (!strcmp(_screenshot_format_name, _screenshot_formats[i].extension)) {

   409

			j = i;

   410

			break;

   411

		}

   412

	_cur_screenshot_format = j;

   413

	_num_screenshot_formats = lengthof(_screenshot_formats);

   414

}

   415

   416

const char *GetScreenshotFormatDesc(int i)

   417

{

   418

	return _screenshot_formats[i].name;

   419

}

   420

   421

void SetScreenshotFormat(int i)

   422

{

   423

	_cur_screenshot_format = i;

   424

	strcpy(_screenshot_format_name, _screenshot_formats[i].extension);

   425

}

   426

   427

// screenshot generator that dumps the current video buffer

   428

static void CurrentScreenCallback(void *userdata, byte *buf, uint y, uint pitch, uint n)

   429

{

   430

	for (; n > 0; --n) {

   431

		memcpy(buf, _screen.dst_ptr + y * _screen.pitch, _screen.width);

   432

		++y;

   433

		buf += pitch;

   434

	}

   435

}

   436

   437

// generate a large piece of the world

   438

static void LargeWorldCallback(void *userdata, byte *buf, uint y, uint pitch, uint n)

   439

{

   440

	ViewPort *vp = (ViewPort *)userdata;

   441

	DrawPixelInfo dpi, *old_dpi;

   442

	int wx, left;

   443

   444

	old_dpi = _cur_dpi;

   445

	_cur_dpi = &dpi;

   446

   447

	dpi.dst_ptr = buf;

   448

	dpi.height = n;

   449

	dpi.width = vp->width;

   450

	dpi.pitch = pitch;

   451

	dpi.zoom = 0;

   452

	dpi.left = 0;

   453

	dpi.top = y;

   454

   455

	left = 0;

   456

	while (vp->width - left != 0) {

   457

		wx = min(vp->width - left, 1600);

   458

		left += wx;

   459

   460

		ViewportDoDraw(vp,

   461

			((left - wx - vp->left) << vp->zoom) + vp->virtual_left,

   462

			((y - vp->top) << vp->zoom) + vp->virtual_top,

   463

			((left - vp->left) << vp->zoom) + vp->virtual_left,

   464

			(((y + n) - vp->top) << vp->zoom) + vp->virtual_top

   465

		);

   466

	}

   467

   468

	_cur_dpi = old_dpi;

   469

}

   470

   471

static char *MakeScreenshotName(const char *ext)

   472

{

   473

	static char filename[256];

   474

	char *base;

   475

	int serial;

   476

   477

	if (_game_mode == GM_EDITOR || _local_player == OWNER_SPECTATOR) {

   478

		sprintf(_screenshot_name, "screenshot");

   479

	} else {

   480

		Player *p = &_players[_local_player];

   481

		SET_DPARAM16(0, p->name_1);

   482

		SET_DPARAM32(1, p->name_2);

   483

		SET_DPARAM16(2, _date);

   484

		GetString(_screenshot_name, STR_4004);

   485

	}

   486

   487

	base = strchr(_screenshot_name, 0);

   488

	base[0] = '.'; strcpy(base + 1, ext);

   489

   490

	serial = 0;

   491

	for (;;) {

   492

		snprintf(filename, sizeof(filename), "%s%s", _path.personal_dir, _screenshot_name);

   493

		if (!FileExists(filename))

   494

			break;

   495

		sprintf(base, " #%d.%s", ++serial, ext);

   496

	}

   497

   498

	return filename;

   499

}

   500

   501

bool MakeScreenshot(void)

   502

{

   503

	const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;

   504

	return sf->proc(MakeScreenshotName(sf->extension), CurrentScreenCallback, NULL, _screen.width, _screen.height, 8, _cur_palette);

   505

}

   506

   507

bool MakeWorldScreenshot(int left, int top, int width, int height, int zoom)

   508

{

   509

	ViewPort vp;

   510

	const ScreenshotFormat *sf;

   511

   512

	vp.zoom = zoom;

   513

	vp.left = 0;

   514

	vp.top = 0;

   515

	vp.virtual_width = width;