1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "fileio.h"

     7

#include "viewport_func.h"

     8

#include "gfx_func.h"

     9

#include "core/math_func.hpp"

    10

#include "screenshot.h"

    11

#include "variables.h"

    12

#include "blitter/factory.hpp"

    13

#include "fileio.h"

    14

#include "strings_func.h"

    15

#include "zoom_func.h"

    16

#include "core/alloc_func.hpp"

    17

#include "core/endian_func.hpp"

    18

#include "map_func.h"

    19

#include "date_func.h"

    20

#include "player_func.h"

    21

    22

#include "table/strings.h"

    23

    24

char _screenshot_format_name[8];

    25

uint _num_screenshot_formats;

    26

uint _cur_screenshot_format;

    27

ScreenshotType current_screenshot_type;

    28

    29

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

    30

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

    31

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

    32

    33

struct ScreenshotFormat {

    34

	const char *name;

    35

	const char *extension;

    36

	ScreenshotHandlerProc *proc;

    37

};

    38

    39

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

    40

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

    41

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

    42

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

    43

#pragma pack(push, 1)

    44

#endif

    45

    46

struct BitmapFileHeader {

    47

	uint16 type;

    48

	uint32 size;

    49

	uint32 reserved;

    50

	uint32 off_bits;

    51

} GCC_PACK;

    52

assert_compile(sizeof(BitmapFileHeader) == 14);

    53

    54

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

    55

#pragma pack(pop)

    56

#endif

    57

    58

struct BitmapInfoHeader {

    59

	uint32 size;

    60

	int32 width, height;

    61

	uint16 planes, bitcount;

    62

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

    63

};

    64

assert_compile(sizeof(BitmapInfoHeader) == 40);

    65

    66

struct RgbQuad {

    67

	byte blue, green, red, reserved;

    68

};

    69

assert_compile(sizeof(RgbQuad) == 4);

    70

    71

/* generic .BMP writer */

    72

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

    73

{

    74

	BitmapFileHeader bfh;

    75

	BitmapInfoHeader bih;

    76

	RgbQuad rq[256];

    77

	FILE *f;

    78

	uint i, padw;

    79

	uint n, maxlines;

    80

	uint pal_size = 0;

    81

	uint bpp = pixelformat / 8;

    82

    83

	/* only implemented for 8bit and 32bit images so far. */

    84

	if (pixelformat != 8 && pixelformat != 32) return false;

    85

    86

	f = fopen(name, "wb");

    87

	if (f == NULL) return false;

    88

    89

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

    90

	padw = Align(w, 4);

    91

    92

	if (pixelformat == 8) pal_size = sizeof(RgbQuad) * 256;

    93

    94

	/* setup the file header */

    95

	bfh.type = TO_LE16('MB');

    96

	bfh.size = TO_LE32(sizeof(bfh) + sizeof(bih) + pal_size + padw * h * bpp);

    97

	bfh.reserved = 0;

    98

	bfh.off_bits = TO_LE32(sizeof(bfh) + sizeof(bih) + pal_size);

    99

   100

	/* setup the info header */

   101

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

   102

	bih.width = TO_LE32(w);

   103

	bih.height = TO_LE32(h);

   104

	bih.planes = TO_LE16(1);

   105

	bih.bitcount = TO_LE16(pixelformat);

   106

	bih.compression = 0;

   107

	bih.sizeimage = 0;

   108

	bih.xpels = 0;

   109

	bih.ypels = 0;

   110

	bih.clrused = 0;

   111

	bih.clrimp = 0;

   112

   113

	if (pixelformat == 8) {

   114

		/* convert the palette to the windows format */

   115

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

   116

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

   117

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

   118

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

   119

			rq[i].reserved = 0;

   120

		}

   121

	}

   122

   123

	/* write file header and info header and palette */

   124

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

   125

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

   126

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

   127

   128

	/* use by default 64k temp memory */

   129

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

   130

   131

	/* now generate the bitmap bits */

   132

	void *buff = MallocT<uint8>(padw * maxlines * bpp); // by default generate 128 lines at a time.

   133

	if (buff == NULL) {

   134

		fclose(f);

   135

		return false;

   136

	}

   137

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

   138

   139

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

   140

	do {

   141

		/* determine # lines */

   142

		n = min(h, maxlines);

   143

		h -= n;

   144

   145

		/* render the pixels */

   146

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

   147

   148

		/* write each line */

   149

		while (n)

   150

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

   151

				free(buff);

   152

				fclose(f);

   153

				return false;

   154

			}

   155

	} while (h != 0);

   156

   157

	free(buff);

   158

	fclose(f);

   159

   160

	return true;

   161

}

   162

   163

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

   164

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

   165

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

   166

#if defined(WITH_PNG)

   167

#include <png.h>

   168

   169

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   170

{

   171

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

   172

	longjmp(png_ptr->jmpbuf, 1);

   173

}

   174

   175

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   176

{

   177

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

   178

}

   179

   180

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

   181

{

   182

	png_color rq[256];

   183

	FILE *f;

   184

	uint i, y, n;

   185

	uint maxlines;

   186

	uint bpp = pixelformat / 8;

   187

	png_structp png_ptr;

   188

	png_infop info_ptr;

   189

   190

	/* only implemented for 8bit and 32bit images so far. */

   191

	if (pixelformat != 8 && pixelformat != 32) return false;

   192

   193

	f = fopen(name, "wb");

   194

	if (f == NULL) return false;

   195

   196

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

   197

   198

	if (png_ptr == NULL) {

   199

		fclose(f);

   200

		return false;

   201

	}

   202

   203

	info_ptr = png_create_info_struct(png_ptr);

   204

	if (info_ptr == NULL) {

   205

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   206

		fclose(f);

   207

		return false;

   208

	}

   209

   210

	if (setjmp(png_jmpbuf(png_ptr))) {

   211

		png_destroy_write_struct(&png_ptr, &info_ptr);

   212

		fclose(f);

   213

		return false;

   214

	}

   215

   216

	png_init_io(png_ptr, f);

   217

   218

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   219

   220

	png_set_IHDR(png_ptr, info_ptr, w, h, 8, pixelformat == 8 ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_RGB,

   221

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   222

   223

	if (pixelformat == 8) {

   224

		/* convert the palette to the .PNG format. */

   225

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

   226

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

   227

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

   228

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

   229

		}

   230

   231

		png_set_PLTE(png_ptr, info_ptr, rq, 256);

   232

	}

   233

   234

	png_write_info(png_ptr, info_ptr);

   235

	png_set_flush(png_ptr, 512);

   236

   237

	if (pixelformat == 32) {

   238

		png_color_8 sig_bit;

   239

   240

		/* Save exact color/alpha resolution */

   241

		sig_bit.alpha = 0;

   242

		sig_bit.blue  = 8;

   243

		sig_bit.green = 8;

   244

		sig_bit.red   = 8;

   245

		sig_bit.gray  = 8;

   246

		png_set_sBIT(png_ptr, info_ptr, &sig_bit);

   247

   248

#ifdef TTD_LITTLE_ENDIAN

   249

		png_set_bgr(png_ptr);

   250

		png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);

   251

#else

   252

		png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

   253

#endif

   254

	}

   255

   256

	/* use by default 64k temp memory */

   257

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

   258

   259

	/* now generate the bitmap bits */

   260

	void *buff = MallocT<uint8>(w * maxlines * bpp); // by default generate 128 lines at a time.

   261

	if (buff == NULL) {

   262

		png_destroy_write_struct(&png_ptr, &info_ptr);

   263

		fclose(f);

   264

		return false;

   265

	}

   266

	memset(buff, 0, w * maxlines * bpp);

   267

   268

	y = 0;

   269

	do {

   270

		/* determine # lines to write */

   271

		n = min(h - y, maxlines);

   272

   273

		/* render the pixels into the buffer */

   274

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

   275

		y += n;

   276

   277

		/* write them to png */

   278

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

   279

			png_write_row(png_ptr, (png_bytep)buff + i * w * bpp);

   280

	} while (y != h);

   281

   282

	png_write_end(png_ptr, info_ptr);

   283

	png_destroy_write_struct(&png_ptr, &info_ptr);

   284

   285

	free(buff);

   286

	fclose(f);

   287

	return true;

   288

}

   289

#endif /* WITH_PNG */

   290

   291

   292

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

   293

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

   294

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

   295

   296

struct PcxHeader {

   297

	byte manufacturer;

   298

	byte version;

   299

	byte rle;

   300

	byte bpp;

   301

	uint32 unused;

   302

	uint16 xmax, ymax;

   303

	uint16 hdpi, vdpi;

   304

	byte pal_small[16 * 3];

   305

	byte reserved;

   306

	byte planes;

   307

	uint16 pitch;

   308

	uint16 cpal;

   309

	uint16 width;

   310

	uint16 height;

   311

	byte filler[54];

   312

};

   313

assert_compile(sizeof(PcxHeader) == 128);

   314

   315

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

   316

{

   317

	FILE *f;

   318

	uint maxlines;

   319

	uint y;

   320

	PcxHeader pcx;

   321

	bool success;

   322

   323

	if (pixelformat == 32) {

   324

		DEBUG(misc, 0, "Can't convert a 32bpp screenshot to PCX format. Please pick an other format.");

   325

		return false;

   326

	}

   327

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

   328

		return false;

   329

   330

	f = fopen(name, "wb");

   331

	if (f == NULL) return false;

   332

   333

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

   334

   335

	/* setup pcx header */

   336

	pcx.manufacturer = 10;

   337

	pcx.version = 5;

   338

	pcx.rle = 1;

   339

	pcx.bpp = 8;

   340

	pcx.xmax = TO_LE16(w - 1);

   341

	pcx.ymax = TO_LE16(h - 1);

   342

	pcx.hdpi = TO_LE16(320);

   343

	pcx.vdpi = TO_LE16(320);

   344

   345

	pcx.planes = 1;

   346

	pcx.cpal = TO_LE16(1);

   347

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

   348

	pcx.height = TO_LE16(h);

   349

   350

	/* write pcx header */

   351

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

   352

		fclose(f);

   353

		return false;

   354

	}

   355

   356

	/* use by default 64k temp memory */

   357

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

   358

   359

	/* now generate the bitmap bits */

   360

	uint8 *buff = MallocT<uint8>(w * maxlines); // by default generate 128 lines at a time.

   361

	if (buff == NULL) {

   362

		fclose(f);

   363

		return false;

   364

	}

   365

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

   366

   367

	y = 0;

   368

	do {

   369

		/* determine # lines to write */

   370

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

   371

		uint i;

   372

   373

		/* render the pixels into the buffer */

   374

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

   375

		y += n;

   376

   377

		/* write them to pcx */

   378

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

   379

			const uint8 *bufp = buff + i * w;

   380

			byte runchar = bufp[0];

   381

			uint runcount = 1;

   382

			uint j;

   383

   384

			/* for each pixel... */

   385

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

   386

				uint8 ch = bufp[j];

   387

   388

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

   389

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

   390

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

   391

							free(buff);

   392

							fclose(f);

   393

							return false;

   394

						}

   395

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

   396

						free(buff);

   397

						fclose(f);

   398

						return false;

   399

					}

   400

					runcount = 0;

   401

					runchar = ch;

   402

				}

   403

				runcount++;

   404

			}

   405

   406

			/* write remaining bytes.. */

   407

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

   408

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

   409

					free(buff);

   410

					fclose(f);

   411

					return false;

   412

				}

   413

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

   414

				free(buff);

   415

				fclose(f);

   416

				return false;

   417

			}

   418

		}

   419

	} while (y != h);

   420

   421

	free(buff);

   422

   423

	/* write 8-bit color palette */

   424

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

   425

		fclose(f);

   426

		return false;

   427

	}

   428

   429

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

   430

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

   431

	} else {

   432

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

   433

		byte tmp[256 * 3];

   434

		uint i;

   435

   436

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

   437

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

   438

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

   439

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

   440

		}

   441

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

   442

	}

   443

   444

	fclose(f);

   445

   446

	return success;

   447

}

   448

   449

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

   450

//*** GENERIC SCREENSHOT CODE

   451

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

   452

   453

static const ScreenshotFormat _screenshot_formats[] = {

   454

#if defined(WITH_PNG)

   455

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

   456

#endif

   457

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

   458

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

   459

};

   460

   461

void InitializeScreenshotFormats()

   462

{

   463

	int i, j;

   464

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

   465

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

   466

			j = i;

   467

			break;

   468

		}

   469

	_cur_screenshot_format = j;

   470

	_num_screenshot_formats = lengthof(_screenshot_formats);

   471

	current_screenshot_type = SC_NONE;

   472

}

   473

   474

const char *GetScreenshotFormatDesc(int i)

   475

{

   476

	return _screenshot_formats[i].name;

   477

}

   478

   479

void SetScreenshotFormat(int i)

   480

{

   481

	_cur_screenshot_format = i;

   482

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

   483

}

   484

   485

/* screenshot generator that dumps the current video buffer */

   486

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

   487

{

   488

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   489

	void *src = blitter->MoveTo(_screen.dst_ptr, 0, y);

   490

	blitter->CopyImageToBuffer(src, buf, _screen.width, n, pitch);

   491

}

   492

   493

/** generate a large piece of the world

   494

 * @param userdata Viewport area to draw

   495

 * @param buf Videobuffer with same bitdepth as current blitter

   496

 * @param y First line to render

   497

 * @param pitch Pitch of the videobuffer