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

    16

char _screenshot_format_name[8];

    17

uint _num_screenshot_formats;

    18

uint _cur_screenshot_format;

    20

    21

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

    22

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

    23

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

    24

    25

typedef struct {

    26

	const char *name;

    27

	const char *extension;

    28

	ScreenshotHandlerProc *proc;

    29

} ScreenshotFormat;

    30

    31

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

    32

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

    33

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

    34

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

    35

#pragma pack(push, 1)

    36

#endif

    37

    38

typedef struct BitmapFileHeader {

    39

	uint16 type;

    40

	uint32 size;

    41

	uint32 reserved;

    42

	uint32 off_bits;

    43

} GCC_PACK BitmapFileHeader;

    44

assert_compile(sizeof(BitmapFileHeader) == 14);

    45

    46

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

    47

#pragma pack(pop)

    48

#endif

    49

    50

typedef struct BitmapInfoHeader {

    51

	uint32 size;

    52

	int32 width, height;

    53

	uint16 planes, bitcount;

    54

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

    55

} BitmapInfoHeader;

    56

assert_compile(sizeof(BitmapInfoHeader) == 40);

    57

    58

typedef struct RgbQuad {

    59

	byte blue, green, red, reserved;

    60

} RgbQuad;

    61

assert_compile(sizeof(RgbQuad) == 4);

    62

    63

// generic .BMP writer

    64

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

    65

{

    66

	BitmapFileHeader bfh;

    67

	BitmapInfoHeader bih;

    68

	RgbQuad rq[256];

    69

	Pixel *buff;

    70

	FILE *f;

    71

	uint i, padw;

    72

	uint n, maxlines;

    73

    74

	// only implemented for 8bit images so far.

    75

	if (pixelformat != 8)

    76

		return false;

    77

    78

	f = fopen(OTTD2FS(name), "wb");

    79

	if (f == NULL) return false;

    80

    81

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

    82

	padw = ALIGN(w, 4);

    83

    84

	// setup the file header

    85

	bfh.type = TO_LE16('MB');

    86

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

    87

	bfh.reserved = 0;

    88

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

    89

    90

	// setup the info header

    91

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

    92

	bih.width = TO_LE32(w);

    93

	bih.height = TO_LE32(h);

    94

	bih.planes = TO_LE16(1);

    95

	bih.bitcount = TO_LE16(8);

    96

	bih.compression = 0;

    97

	bih.sizeimage = 0;

    98

	bih.xpels = 0;

    99

	bih.ypels = 0;

   100

	bih.clrused = 0;

   101

	bih.clrimp = 0;

   102

   103

	// convert the palette to the windows format

   104

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

   105

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

   106

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

   107

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

   108

		rq[i].reserved = 0;

   109

	}

   110

   111

	// write file header and info header and palette

   112

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

   113

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

   114

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

   115

   116

	// use by default 64k temp memory

   117

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

   118

   119

	// now generate the bitmap bits

   120

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

   121

	if (buff == NULL) {

   122

		fclose(f);

   123

		return false;

   124

	}

   125

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

   126

   127

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

   128

	do {

   129

		// determine # lines

   130

		n = min(h, maxlines);

   131

		h -= n;

   132

   133

		// render the pixels

   134

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

   135

   136

		// write each line

   137

		while (n)

   138

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

   139

				free(buff);

   140

				fclose(f);

   141

				return false;

   142

			}

   143

	} while (h != 0);

   144

   145

	free(buff);

   146

	fclose(f);

   147

   148

	return true;

   149

}

   150

   151

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

   152

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

   153

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

   154

#if defined(WITH_PNG)

   155

#include <png.h>

   156

   157

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   158

{

   159

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

   160

	longjmp(png_ptr->jmpbuf, 1);

   161

}

   162

   163

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   164

{

   165

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

   166

}

   167

   168

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

   169

{

   170

	png_color rq[256];

   171

	Pixel *buff;

   172

	FILE *f;

   173

	uint i, y, n;

   174

	uint maxlines;

   175

	png_structp png_ptr;

   176

	png_infop info_ptr;

   177

   178

	// only implemented for 8bit images so far.

   179

	if (pixelformat != 8)

   180

		return false;

   181

   182

	f = fopen(OTTD2FS(name), "wb");

   183

	if (f == NULL) return false;

   184

   185

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

   186

   187

	if (png_ptr == NULL) {

   188

		fclose(f);

   189

		return false;

   190

	}

   191

   192

	info_ptr = png_create_info_struct(png_ptr);

   193

	if (info_ptr == NULL) {

   194

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   195

		fclose(f);

   196

		return false;

   197

	}

   198

   199

	if (setjmp(png_jmpbuf(png_ptr))) {

   200

		png_destroy_write_struct(&png_ptr, &info_ptr);

   201

		fclose(f);

   202

		return false;

   203

	}

   204

   205

	png_init_io(png_ptr, f);

   206

   207

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   208

   209

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

   210

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   211

   212

	// convert the palette to the .PNG format.

   213

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

   214

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

   215

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

   216

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

   217

	}

   218

   219

	png_set_PLTE(png_ptr, info_ptr, rq, 256);

   220

	png_write_info(png_ptr, info_ptr);

   221

	png_set_flush(png_ptr, 512);

   222

   223

	// use by default 64k temp memory

   224

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

   225

   226

	// now generate the bitmap bits

   227

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

   228

	if (buff == NULL) {

   229

		png_destroy_write_struct(&png_ptr, &info_ptr);

   230

		fclose(f);

   231

		return false;

   232

	}

   233

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

   234

   235

	y = 0;

   236

	do {

   237

		// determine # lines to write

   238

		n = min(h - y, maxlines);

   239

   240

		// render the pixels into the buffer

   241

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

   242

		y += n;

   243

   244

		// write them to png

   245

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

   246

			png_write_row(png_ptr, buff + i * w);

   247

	} while (y != h);

   248

   249

	png_write_end(png_ptr, info_ptr);

   250

	png_destroy_write_struct(&png_ptr, &info_ptr);

   251

   252

	free(buff);

   253

	fclose(f);

   254

	return true;

   255

}

   256

#endif // WITH_PNG

   257

   258

   259

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

   260

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

   261

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

   262

   263

typedef struct {

   264

	byte manufacturer;

   265

	byte version;

   266

	byte rle;

   267

	byte bpp;

   268

	uint32 unused;

   269

	uint16 xmax, ymax;

   270

	uint16 hdpi, vdpi;

   271

	byte pal_small[16*3];

   272

	byte reserved;

   273

	byte planes;

   274

	uint16 pitch;

   275

	uint16 cpal;

   276

	uint16 width;

   277

	uint16 height;

   278

	byte filler[54];

   279

} PcxHeader;

   280

assert_compile(sizeof(PcxHeader) == 128);

   281

   282

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

   283

{

   284

	Pixel *buff;

   285

	FILE *f;

   286

	uint maxlines;

   287

	uint y;

   288

	PcxHeader pcx;

   289

	bool success;

   290

   291

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

   292

		return false;

   293

   294

	f = fopen(OTTD2FS(name), "wb");

   295

	if (f == NULL) return false;

   296

   297

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

   298

   299

	// setup pcx header

   300

	pcx.manufacturer = 10;

   301

	pcx.version = 5;

   302

	pcx.rle = 1;

   303

	pcx.bpp = 8;

   304

	pcx.xmax = TO_LE16(w - 1);

   305

	pcx.ymax = TO_LE16(h - 1);

   306

	pcx.hdpi = TO_LE16(320);

   307

	pcx.vdpi = TO_LE16(320);

   308

   309

	pcx.planes = 1;

   310

	pcx.cpal = TO_LE16(1);

   311

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

   312

	pcx.height = TO_LE16(h);

   313

   314

	// write pcx header

   315

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

   316

		fclose(f);

   317

		return false;

   318

	}

   319

   320

	// use by default 64k temp memory

   321

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

   322

   323

	// now generate the bitmap bits

   324

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

   325

	if (buff == NULL) {

   326

		fclose(f);

   327

		return false;

   328

	}

   329

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

   330

   331

	y = 0;

   332

	do {

   333

		// determine # lines to write

   334

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

   335

		uint i;

   336

   337

		// render the pixels into the buffer

   338

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

   339

		y += n;

   340

   341

		// write them to pcx

   342

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

   343

			const Pixel* bufp = buff + i * w;

   344

			byte runchar = bufp[0];

   345

			uint runcount = 1;

   346

			uint j;

   347

   348

			// for each pixel...

   349

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

   350

				Pixel ch = bufp[j];

   351

   352

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

   353

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

   354

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

   355

							free(buff);

   356

							fclose(f);

   357

							return false;

   358

						}

   359

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

   360

						free(buff);

   361

						fclose(f);

   362

						return false;

   363

					}

   364

					runcount = 0;

   365

					runchar = ch;

   366

				}

   367

				runcount++;

   368

			}

   369

   370

			// write remaining bytes..

   371

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

   372

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

   373

					free(buff);

   374

					fclose(f);

   375

					return false;

   376

				}

   377

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

   378

				free(buff);

   379

				fclose(f);

   380

				return false;

   381

			}

   382

		}

   383

	} while (y != h);

   384

   385

	free(buff);

   386

   387

	// write 8-bit color palette

   388

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

   389

		fclose(f);

   390

		return false;

   391

	}

   392

   393

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

   394

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

   395

	} else {

   396

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

   397

		byte tmp[256 * 3];

   398

		uint i;

   399

   400

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

   401

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

   402

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

   403

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

   404

		}

   405

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

   406

	}

   407

   408

	fclose(f);

   409

   410

	return success;

   411

}

   412

   413

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

   414

//*** GENERIC SCREENSHOT CODE

   415

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

   416

   417

static const ScreenshotFormat _screenshot_formats[] = {

   418

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

   419

#if defined(WITH_PNG)

   420

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

   421

#endif

   422

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

   423

};

   424

   425

void InitializeScreenshotFormats(void)

   426

{

   427

	int i, j;

   428

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

   429

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

   430

			j = i;

   431

			break;

   432

		}

   433

	_cur_screenshot_format = j;

   434

	_num_screenshot_formats = lengthof(_screenshot_formats);

   436

}

   437

   438

const char *GetScreenshotFormatDesc(int i)

   439

{

   440

	return _screenshot_formats[i].name;

   441

}

   442

   443

void SetScreenshotFormat(int i)

   444

{

   445

	_cur_screenshot_format = i;

   446

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

   447

}

   448

   449

// screenshot generator that dumps the current video buffer

   450

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

   451

{

   452

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

   453

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

   454

		++y;

   455

		buf += pitch;

   456

	}

   457

}

   458

   459

// generate a large piece of the world

   460

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

   461

{

   462

	ViewPort *vp = (ViewPort *)userdata;

   463

	DrawPixelInfo dpi, *old_dpi;

   464

	int wx, left;

   465

   466

	old_dpi = _cur_dpi;

   467

	_cur_dpi = &dpi;

   468

   469

	dpi.dst_ptr = buf;

   470

	dpi.height = n;

   471

	dpi.width = vp->width;

   472

	dpi.pitch = pitch;

   473

	dpi.zoom = 0;

   474

	dpi.left = 0;

   475

	dpi.top = y;

   476

   477

	left = 0;

   478

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

   479

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

   480

		left += wx;

   481

   482

		ViewportDoDraw(vp,

   483

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

   484

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

   485

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

   486

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

   487

		);

   488

	}

   489

   490

	_cur_dpi = old_dpi;

   491

}

   492

   493

static char *MakeScreenshotName(const char *ext)

   494

{

   495

	static char filename[256];

   496

	char *base;

   497

	int serial;

   498

   499

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

   500

		sprintf(_screenshot_name, "screenshot");

   501

	} else {

   502

		const Player* p = GetPlayer(_local_player);

   503

		SetDParam(0, p->name_1);

   504

		SetDParam(1, p->name_2);

   505

		SetDParam(2, _date);

   506

		GetString(_screenshot_name, STR_4004);

   507

	}

   508