1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "strings.h"

     8

#include "table/strings.h"

     9

#include "gfx.h"

    10

#include "hal.h"

    11

#include "viewport.h"

    12

#include "player.h"

    13

#include "screenshot.h"

    14

#include "variables.h"

    15

#include "date.h"

    16

#include "helpers.hpp"

    17

    18

char _screenshot_format_name[8];

    19

uint _num_screenshot_formats;

    20

uint _cur_screenshot_format;

    21

ScreenshotType current_screenshot_type;

    22

    23

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

    24

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

    25

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

    26

    27

typedef struct {

    28

	const char *name;

    29

	const char *extension;

    30

	ScreenshotHandlerProc *proc;

    31

} ScreenshotFormat;

    32

    33

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

    34

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

    35

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

    36

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

    37

#pragma pack(push, 1)

    38

#endif

    39

    40

typedef struct BitmapFileHeader {

    41

	uint16 type;

    42

	uint32 size;

    43

	uint32 reserved;

    44

	uint32 off_bits;

    45

} GCC_PACK BitmapFileHeader;

    46

assert_compile(sizeof(BitmapFileHeader) == 14);

    47

    48

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

    49

#pragma pack(pop)

    50

#endif

    51

    52

typedef struct BitmapInfoHeader {

    53

	uint32 size;

    54

	int32 width, height;

    55

	uint16 planes, bitcount;

    56

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

    57

} BitmapInfoHeader;

    58

assert_compile(sizeof(BitmapInfoHeader) == 40);

    59

    60

typedef struct RgbQuad {

    61

	byte blue, green, red, reserved;

    62

} RgbQuad;

    63

assert_compile(sizeof(RgbQuad) == 4);

    64

    65

// generic .BMP writer

    66

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

    67

{

    68

	BitmapFileHeader bfh;

    69

	BitmapInfoHeader bih;

    70

	RgbQuad rq[256];

    71

	Pixel *buff;

    72

	FILE *f;

    73

	uint i, padw;

    74

	uint n, maxlines;

    75

    76

	// only implemented for 8bit images so far.

    77

	if (pixelformat != 8)

    78

		return false;

    79

    80

	f = fopen(name, "wb");

    81

	if (f == NULL) return false;

    82

    83

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

    84

	padw = ALIGN(w, 4);

    85

    86

	// setup the file header

    87

	bfh.type = TO_LE16('MB');

    88

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

    89

	bfh.reserved = 0;

    90

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

    91

    92

	// setup the info header

    93

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

    94

	bih.width = TO_LE32(w);

    95

	bih.height = TO_LE32(h);

    96

	bih.planes = TO_LE16(1);

    97

	bih.bitcount = TO_LE16(8);

    98

	bih.compression = 0;

    99

	bih.sizeimage = 0;

   100

	bih.xpels = 0;

   101

	bih.ypels = 0;

   102

	bih.clrused = 0;

   103

	bih.clrimp = 0;

   104

   105

	// convert the palette to the windows format

   106

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

   107

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

   108

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

   109

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

   110

		rq[i].reserved = 0;

   111

	}

   112

   113

	// write file header and info header and palette

   114

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

   115

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

   116

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

   117

   118

	// use by default 64k temp memory

   119

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

   120

   121

	// now generate the bitmap bits

   122

	MallocT(&buff, padw * maxlines); // by default generate 128 lines at a time.

   123

	if (buff == NULL) {

   124

		fclose(f);

   125

		return false;

   126

	}

   127

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

   128

   129

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

   130

	do {

   131

		// determine # lines

   132

		n = min(h, maxlines);

   133

		h -= n;

   134

   135

		// render the pixels

   136

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

   137

   138

		// write each line

   139

		while (n)

   140

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

   141

				free(buff);

   142

				fclose(f);

   143

				return false;

   144

			}

   145

	} while (h != 0);

   146

   147

	free(buff);

   148

	fclose(f);

   149

   150

	return true;

   151

}

   152

   153

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

   154

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

   155

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

   156

#if defined(WITH_PNG)

   157

#include <png.h>

   158

   159

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   160

{

   161

	DEBUG(misc, 0, "[libpng] error: %s - %s", message, (char *)png_get_error_ptr(png_ptr));

   162

	longjmp(png_ptr->jmpbuf, 1);

   163

}

   164

   165

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   166

{

   167

	DEBUG(misc, 1, "[libpng] warning: %s - %s", message, (char *)png_get_error_ptr(png_ptr));

   168

}

   169

   170

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

   171

{

   172

	png_color rq[256];

   173

	Pixel *buff;

   174

	FILE *f;

   175

	uint i, y, n;

   176

	uint maxlines;

   177

	png_structp png_ptr;

   178

	png_infop info_ptr;

   179

   180

	// only implemented for 8bit images so far.

   181

	if (pixelformat != 8)

   182

		return false;

   183

   184

	f = fopen(name, "wb");

   185

	if (f == NULL) return false;

   186

   187

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

   188

   189

	if (png_ptr == NULL) {

   190

		fclose(f);

   191

		return false;

   192

	}

   193

   194

	info_ptr = png_create_info_struct(png_ptr);

   195

	if (info_ptr == NULL) {

   196

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   197

		fclose(f);

   198

		return false;

   199

	}

   200

   201

	if (setjmp(png_jmpbuf(png_ptr))) {

   202

		png_destroy_write_struct(&png_ptr, &info_ptr);

   203

		fclose(f);

   204

		return false;

   205

	}

   206

   207

	png_init_io(png_ptr, f);

   208

   209

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   210

   211

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

   212

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   213

   214

	// convert the palette to the .PNG format.

   215

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

   216

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

   217

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

   218

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

   219

	}

   220

   221

	png_set_PLTE(png_ptr, info_ptr, rq, 256);

   222

	png_write_info(png_ptr, info_ptr);

   223

	png_set_flush(png_ptr, 512);

   224

   225

	// use by default 64k temp memory

   226

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

   227

   228

	// now generate the bitmap bits

   229

	MallocT(&buff, w * maxlines); // by default generate 128 lines at a time.

   230

	if (buff == NULL) {

   231

		png_destroy_write_struct(&png_ptr, &info_ptr);

   232

		fclose(f);

   233

		return false;

   234

	}

   235

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

   236

   237

	y = 0;

   238

	do {

   239

		// determine # lines to write

   240

		n = min(h - y, maxlines);

   241

   242

		// render the pixels into the buffer

   243

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

   244

		y += n;

   245

   246

		// write them to png

   247

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

   248

			png_write_row(png_ptr, buff + i * w);

   249

	} while (y != h);

   250

   251

	png_write_end(png_ptr, info_ptr);

   252

	png_destroy_write_struct(&png_ptr, &info_ptr);

   253

   254

	free(buff);

   255

	fclose(f);

   256

	return true;

   257

}

   258

#endif /* WITH_PNG */

   259

   260

   261

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

   262

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

   263

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

   264

   265

typedef struct {

   266

	byte manufacturer;

   267

	byte version;

   268

	byte rle;

   269

	byte bpp;

   270

	uint32 unused;

   271

	uint16 xmax, ymax;

   272

	uint16 hdpi, vdpi;

   273

	byte pal_small[16*3];

   274

	byte reserved;

   275

	byte planes;

   276

	uint16 pitch;

   277

	uint16 cpal;

   278

	uint16 width;

   279

	uint16 height;

   280

	byte filler[54];

   281

} PcxHeader;

   282

assert_compile(sizeof(PcxHeader) == 128);

   283

   284

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

   285

{

   286

	Pixel *buff;

   287

	FILE *f;

   288

	uint maxlines;

   289

	uint y;

   290

	PcxHeader pcx;

   291

	bool success;

   292

   293

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

   294

		return false;

   295

   296

	f = fopen(name, "wb");

   297

	if (f == NULL) return false;

   298

   299

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

   300

   301

	// setup pcx header

   302

	pcx.manufacturer = 10;

   303

	pcx.version = 5;

   304

	pcx.rle = 1;

   305

	pcx.bpp = 8;

   306

	pcx.xmax = TO_LE16(w - 1);

   307

	pcx.ymax = TO_LE16(h - 1);

   308

	pcx.hdpi = TO_LE16(320);

   309

	pcx.vdpi = TO_LE16(320);

   310

   311

	pcx.planes = 1;

   312

	pcx.cpal = TO_LE16(1);

   313

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

   314

	pcx.height = TO_LE16(h);

   315

   316

	// write pcx header

   317

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

   318

		fclose(f);

   319

		return false;

   320

	}

   321

   322

	// use by default 64k temp memory

   323

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

   324

   325

	// now generate the bitmap bits

   326

	MallocT(&buff, w * maxlines); // by default generate 128 lines at a time.

   327

	if (buff == NULL) {

   328

		fclose(f);

   329

		return false;

   330

	}

   331

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

   332

   333

	y = 0;

   334

	do {

   335

		// determine # lines to write

   336

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

   337

		uint i;

   338

   339

		// render the pixels into the buffer

   340

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

   341

		y += n;

   342

   343

		// write them to pcx

   344

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

   345

			const Pixel* bufp = buff + i * w;

   346

			byte runchar = bufp[0];

   347

			uint runcount = 1;

   348

			uint j;

   349

   350

			// for each pixel...

   351

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

   352

				Pixel ch = bufp[j];

   353

   354

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

   355

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

   356

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

   357

							free(buff);

   358

							fclose(f);

   359

							return false;

   360

						}

   361

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

   362

						free(buff);

   363

						fclose(f);

   364

						return false;

   365

					}

   366

					runcount = 0;

   367

					runchar = ch;

   368

				}

   369

				runcount++;

   370

			}

   371

   372

			// write remaining bytes..

   373

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

   374

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

   375

					free(buff);

   376

					fclose(f);

   377

					return false;

   378

				}

   379

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

   380

				free(buff);

   381

				fclose(f);

   382

				return false;

   383

			}

   384

		}

   385

	} while (y != h);

   386

   387

	free(buff);

   388

   389

	// write 8-bit color palette

   390

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

   391

		fclose(f);

   392

		return false;

   393

	}

   394

   395

	if (sizeof(*palette) == 3) {

   396

		success = fwrite(palette, 256 * sizeof(*palette), 1, f) == 1;

   397

	} else {

   398

		/* If the palette is word-aligned, copy it to a temporary byte array */

   399

		byte tmp[256 * 3];

   400

		uint i;

   401

   402

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

   403

			tmp[i * 3 + 0] = palette[i].r;

   404

			tmp[i * 3 + 1] = palette[i].g;

   405

			tmp[i * 3 + 2] = palette[i].b;

   406

		}

   407

		success = fwrite(tmp, sizeof(tmp), 1, f) == 1;

   408

	}

   409

   410

	fclose(f);

   411

   412

	return success;

   413

}

   414

   415

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

   416

//*** GENERIC SCREENSHOT CODE

   417

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

   418

   419

static const ScreenshotFormat _screenshot_formats[] = {

   420

#if defined(WITH_PNG)

   421

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

   422

#endif

   423

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

   424

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

   425

};

   426

   427

void InitializeScreenshotFormats(void)

   428

{

   429

	int i, j;

   430

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

   431

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

   432

			j = i;

   433

			break;

   434

		}

   435

	_cur_screenshot_format = j;

   436

	_num_screenshot_formats = lengthof(_screenshot_formats);

   437

	current_screenshot_type = SC_NONE;

   438

}

   439

   440

const char *GetScreenshotFormatDesc(int i)

   441

{

   442

	return _screenshot_formats[i].name;

   443

}

   444

   445

void SetScreenshotFormat(int i)

   446

{

   447

	_cur_screenshot_format = i;

   448

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

   449

}

   450

   451

// screenshot generator that dumps the current video buffer

   452

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

   453

{

   454

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

   455

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

   456

		++y;

   457

		buf += pitch;

   458

	}

   459

}

   460

   461

// generate a large piece of the world

   462

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

   463

{

   464

	ViewPort *vp = (ViewPort *)userdata;

   465

	DrawPixelInfo dpi, *old_dpi;

   466

	int wx, left;

   467

   468

	old_dpi = _cur_dpi;

   469

	_cur_dpi = &dpi;

   470

   471

	dpi.dst_ptr = buf;

   472

	dpi.height = n;

   473

	dpi.width = vp->width;

   474

	dpi.pitch = pitch;

   475

	dpi.zoom = 0;

   476

	dpi.left = 0;

   477

	dpi.top = y;

   478

   479

	left = 0;

   480

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

   481

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

   482

		left += wx;

   483

   484

		ViewportDoDraw(vp,

   485

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

   486

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

   487

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

   488

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

   489

		);

   490

	}

   491

   492

	_cur_dpi = old_dpi;

   493

}

   494

   495

static char *MakeScreenshotName(const char *ext)

   496

{

   497

	static char filename[256];

   498

	char *base;

   499

	int serial;

   500

   501

	if (_game_mode == GM_EDITOR || _game_mode == GM_MENU || _local_player == PLAYER_SPECTATOR) {

   502

		sprintf(_screenshot_name, "screenshot");

   503

	} else {

   504

		const Player* p = GetPlayer(_local_player);

   505

		SetDParam(0, p->name_1);

   506

		SetDParam(1, p->name_2);

   507

		SetDParam(2, _date);