1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "strings.h"

     5

#include "table/strings.h"

     6

#include "gfx.h"

     7

#include "viewport.h"

     8

#include "player.h"

     9

#include "gui.h"

    10

#include "screenshot.h"

    11

    12

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

    13

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

    14

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

    15

    16

typedef struct {

    17

	const char *name;

    18

	const char *extension;

    19

	ScreenshotHandlerProc *proc;

    20

} ScreenshotFormat;

    21

    22

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

    23

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

    24

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

    25

#if defined(_MSC_VER) || defined(__WATCOMC__)

    26

#pragma pack(push, 1)

    27

#endif

    28

    29

typedef struct BitmapFileHeader {

    30

	uint16 type;

    31

	uint32 size;

    32

	uint32 reserved;

    33

	uint32 off_bits;

    34

} GCC_PACK BitmapFileHeader;

    35

assert_compile(sizeof(BitmapFileHeader) == 14);

    36

    37

#if defined(_MSC_VER) || defined(__WATCOMC__)

    38

#pragma pack(pop)

    39

#endif

    40

    41

typedef struct BitmapInfoHeader {

    42

	uint32 size;

    43

	int32 width, height;

    44

	uint16 planes, bitcount;

    45

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

    46

} BitmapInfoHeader;

    47

assert_compile(sizeof(BitmapInfoHeader) == 40);

    48

    49

typedef struct RgbQuad {

    50

	byte blue, green, red, reserved;

    51

} RgbQuad;

    52

assert_compile(sizeof(RgbQuad) == 4);

    53

    54

// generic .BMP writer

    55

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

    56

{

    57

	BitmapFileHeader bfh;

    58

	BitmapInfoHeader bih;

    59

	RgbQuad rq[256];

    60

	byte *buff;

    61

	FILE *f;

    62

	uint i, padw;

    63

	uint n, maxlines;

    64

    65

	// only implemented for 8bit images so far.

    66

	if (pixelformat != 8)

    67

		return false;

    68

    69

	f = fopen(name, "wb");

    70

	if (f == NULL) return false;

    71

    72

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

    73

	padw = (w + 3) & ~3;

    74

    75

	// setup the file header

    76

	bfh.type = TO_LE16('MB');

    77

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

    78

	bfh.reserved = 0;

    79

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

    80

    81

	// setup the info header

    82

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

    83

	bih.width = TO_LE32(w);

    84

	bih.height = TO_LE32(h);

    85

	bih.planes = TO_LE16(1);

    86

	bih.bitcount = TO_LE16(8);

    87

	bih.compression = 0;

    88

	bih.sizeimage = 0;

    89

	bih.xpels = 0;

    90

	bih.ypels = 0;

    91

	bih.clrused = 0;

    92

	bih.clrimp = 0;

    93

    94

	// convert the palette to the windows format

    95

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

    96

		rq[i].red   = palette[i].r;

    97

		rq[i].green = palette[i].g;

    98

		rq[i].blue  = palette[i].b;

    99

		rq[i].reserved = 0;

   100

	}

   101

   102

	// write file header and info header and palette

   103

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

   104

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

   105

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

   106

   107

	// use by default 64k temp memory

   108

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

   109

   110

	// now generate the bitmap bits

   111

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

   112

	if (buff == NULL) {

   113

		fclose(f);

   114

		return false;

   115

	}

   116

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

   117

   118

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

   119

	do {

   120

		// determine # lines

   121

		n = min(h, maxlines);

   122

		h -= n;

   123

   124

		// render the pixels

   125

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

   126

   127

		// write each line

   128

		while (n)

   129

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

   130

				free(buff);

   131

				fclose(f);

   132

				return false;

   133

			}

   134

	} while (h != 0);

   135

   136

	free(buff);

   137

	fclose(f);

   138

   139

	return true;

   140

}

   141

   142

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

   143

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

   144

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

   145

#if defined(WITH_PNG)

   146

#include <png.h>

   147

   148

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   149

{

   150

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

   151

	longjmp(png_ptr->jmpbuf, 1);

   152

}

   153

   154

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   155

{

   156

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

   157

}

   158

   159

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

   160

{

   161

	png_color rq[256];

   162

	byte *buff;

   163

	FILE *f;

   164

	uint i, y, n;

   165

	uint maxlines;

   166

	png_structp png_ptr;

   167

	png_infop info_ptr;

   168

   169

	// only implemented for 8bit images so far.

   170

	if (pixelformat != 8)

   171

		return false;

   172

   173

	f = fopen(name, "wb");

   174

	if (f == NULL) return false;

   175

   176

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

   177

   178

	if (png_ptr == NULL) {

   179

		fclose(f);

   180

		return false;

   181

	}

   182

   183

	info_ptr = png_create_info_struct(png_ptr);

   184

	if (info_ptr == NULL) {

   185

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   186

		fclose(f);

   187

		return false;

   188

	}

   189

   190

	if (setjmp(png_jmpbuf(png_ptr))) {

   191

		png_destroy_write_struct(&png_ptr, &info_ptr);

   192

		fclose(f);

   193

		return false;

   194

	}

   195

   196

	png_init_io(png_ptr, f);

   197

   198

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   199

   200

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

   201

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   202

   203

	// convert the palette to the .PNG format.

   204

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

   205

		rq[i].red   = palette[i].r;

   206

		rq[i].green = palette[i].g;

   207

		rq[i].blue  = palette[i].b;

   208

	}

   209

   210

	png_set_PLTE(png_ptr, info_ptr, rq, 256);

   211

	png_write_info(png_ptr, info_ptr);

   212

	png_set_flush(png_ptr, 512);

   213

   214

	// use by default 64k temp memory

   215

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

   216

   217

	// now generate the bitmap bits

   218

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

   219

	if (buff == NULL) {

   220

		png_destroy_write_struct(&png_ptr, &info_ptr);

   221

		fclose(f);

   222

		return false;

   223

	}

   224

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

   225

   226

	y = 0;

   227

	do {

   228

		// determine # lines to write

   229

		n = min(h - y, maxlines);

   230

   231

		// render the pixels into the buffer

   232

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

   233

		y += n;

   234

   235

		// write them to png

   236

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

   237

			png_write_row(png_ptr, buff + i * w);

   238

	} while (y != h);

   239

   240

	png_write_end(png_ptr, info_ptr);

   241

	png_destroy_write_struct(&png_ptr, &info_ptr);

   242

   243

	free(buff);

   244

	fclose(f);

   245

	return true;

   246

}

   247

#endif // WITH_PNG

   248

   249

   250

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

   251

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

   252

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

   253

   254

typedef struct {

   255

	byte manufacturer;

   256

	byte version;

   257

	byte rle;

   258

	byte bpp;

   259

	uint32 unused;

   260

	uint16 xmax, ymax;

   261

	uint16 hdpi, vdpi;

   262

	byte pal_small[16*3];

   263

	byte reserved;

   264

	byte planes;

   265

	uint16 pitch;

   266

	uint16 cpal;

   267

	uint16 width;

   268

	uint16 height;

   269

	byte filler[54];

   270

} PcxHeader;

   271

assert_compile(sizeof(PcxHeader) == 128);

   272

   273

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

   274

{

   275

	byte *buff;

   276

	FILE *f;

   277

	uint maxlines;

   278

	uint y;

   279

	PcxHeader pcx;

   280

   281

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

   282

		return false;

   283

   284

	f = fopen(name, "wb");

   285

	if (f == NULL) return false;

   286

   287

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

   288

   289

	// setup pcx header

   290

	pcx.manufacturer = 10;

   291

	pcx.version = 5;

   292

	pcx.rle = 1;

   293

	pcx.bpp = 8;

   294

	pcx.xmax = TO_LE16(w - 1);

   295

	pcx.ymax = TO_LE16(h - 1);

   296

	pcx.hdpi = TO_LE16(320);

   297

	pcx.vdpi = TO_LE16(320);

   298

   299

	pcx.planes = 1;

   300

	pcx.cpal = TO_LE16(1);

   301

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

   302

	pcx.height = TO_LE16(h);

   303

   304

	// write pcx header

   305

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

   306

		fclose(f);

   307

		return false;

   308

	}

   309

   310

	// use by default 64k temp memory

   311

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

   312

   313

	// now generate the bitmap bits

   314

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

   315

	if (buff == NULL) {

   316

		fclose(f);

   317

		return false;

   318

	}

   319

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

   320

   321

	y = 0;

   322

	do {

   323

		// determine # lines to write

   324

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

   325

		uint i;

   326

   327

		// render the pixels into the buffer

   328

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

   329

		y += n;

   330

   331

		// write them to pcx

   332

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

   333

			const byte* bufp = buff + i * w;

   334

			byte runchar = bufp[0];

   335

			uint runcount = 1;

   336

			uint j;

   337

   338

			// for each pixel...

   339

			for (j = 1; j < w; j++) {

   340

				byte ch = bufp[j];

   341

   342

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

   343

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

   344

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

   345

							free(buff);

   346

							fclose(f);

   347

							return false;

   348

						}

   349

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

   350

						free(buff);

   351

						fclose(f);

   352

						return false;

   353

					}

   354

					runcount = 0;

   355

					runchar = ch;

   356

				}

   357

				runcount++;

   358

			}

   359

   360

			// write remaining bytes..

   361

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

   362

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

   363

					free(buff);

   364

					fclose(f);

   365

					return false;

   366

				}

   367

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

   368

				free(buff);

   369

				fclose(f);

   370

				return false;

   371

			}

   372

		}

   373

	} while (y != h);

   374

   375

	free(buff);

   376

   377

	// write 8-bit color palette

   378

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

   379

		fclose(f);

   380

		return false;

   381

	}

   382

   383

	{assert_compile(sizeof(*palette) == 3);}

   384

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

   385

		fclose(f);

   386

		return false;

   387

	}

   388

	fclose(f);

   389

   390

	return true;

   391

}

   392

   393

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

   394

//*** GENERIC SCREENSHOT CODE

   395

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

   396

   397

static const ScreenshotFormat _screenshot_formats[] = {

   398

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

   399

#if defined(WITH_PNG)

   400

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

   401

#endif

   402

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

   403

};

   404

   405

void InitializeScreenshotFormats(void)

   406

{

   407

	int i, j;

   408

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

   409

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

   410

			j = i;

   411

			break;

   412

		}

   413

	_cur_screenshot_format = j;

   414

	_num_screenshot_formats = lengthof(_screenshot_formats);

   415

}

   416

   417

const char *GetScreenshotFormatDesc(int i)

   418

{

   419

	return _screenshot_formats[i].name;

   420

}

   421

   422

void SetScreenshotFormat(int i)

   423

{

   424

	_cur_screenshot_format = i;

   425

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

   426

}

   427

   428

// screenshot generator that dumps the current video buffer

   429

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

   430

{

   431

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

   432

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

   433

		++y;

   434

		buf += pitch;

   435

	}

   436

}

   437

   438

// generate a large piece of the world

   439

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

   440

{

   441

	ViewPort *vp = (ViewPort *)userdata;

   442

	DrawPixelInfo dpi, *old_dpi;

   443

	int wx, left;

   444

   445

	old_dpi = _cur_dpi;

   446

	_cur_dpi = &dpi;

   447

   448

	dpi.dst_ptr = buf;

   449

	dpi.height = n;

   450

	dpi.width = vp->width;

   451

	dpi.pitch = pitch;

   452

	dpi.zoom = 0;

   453

	dpi.left = 0;

   454

	dpi.top = y;

   455

   456

	left = 0;

   457

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

   458

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

   459

		left += wx;

   460

   461

		ViewportDoDraw(vp,

   462

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

   463

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

   464

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

   465

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

   466

		);

   467

	}

   468

   469

	_cur_dpi = old_dpi;

   470

}

   471

   472

static char *MakeScreenshotName(const char *ext)

   473

{

   474

	static char filename[256];

   475

	char *base;

   476

	int serial;

   477

   478

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

   479

		sprintf(_screenshot_name, "screenshot");

   480

	} else {

   481

		Player *p = &_players[_local_player];

   482

		SetDParam(0, p->name_1);

   483

		SetDParam(1, p->name_2);

   484

		SetDParam(2, _date);

   485

		GetString(_screenshot_name, STR_4004);

   486

	}

   487

   488

	base = strchr(_screenshot_name, 0);

   489

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

   490

   491

	serial = 0;

   492

	for (;;) {

   493

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

   494

		if (!FileExists(filename))

   495

			break;

   496

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

   497

	}

   498

   499

	return filename;

   500

}

   501

   502

bool MakeScreenshot(void)

   503

{

   504

	const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;

   505

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

   506

}

   507

   508

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

   509

{

   510

	ViewPort vp;

   511

	const ScreenshotFormat *sf;

   512