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 "fileio.h"

    12

#include "viewport.h"

    13

#include "player.h"

    14

#include "screenshot.h"

    15

#include "variables.h"

    16

#include "date.h"

    17

#include "string.h"

    18

#include "helpers.hpp"

    19

#include "blitter/factory.hpp"

    20

#include "fileio.h"

    21

    22

char _screenshot_format_name[8];

    23

uint _num_screenshot_formats;

    24

uint _cur_screenshot_format;

    25

ScreenshotType current_screenshot_type;

    26

    27

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

    28

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

    29

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

    30

    31

struct ScreenshotFormat {

    32

	const char *name;

    33

	const char *extension;

    34

	ScreenshotHandlerProc *proc;

    35

};

    36

    37

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

    38

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

    39

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

    40

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

    41

#pragma pack(push, 1)

    42

#endif

    43

    44

struct BitmapFileHeader {

    45

	uint16 type;

    46

	uint32 size;

    47

	uint32 reserved;

    48

	uint32 off_bits;

    49

} GCC_PACK;

    50

assert_compile(sizeof(BitmapFileHeader) == 14);

    51

    52

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

    53

#pragma pack(pop)

    54

#endif

    55

    56

struct BitmapInfoHeader {

    57

	uint32 size;

    58

	int32 width, height;

    59

	uint16 planes, bitcount;

    60

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

    61

};

    62

assert_compile(sizeof(BitmapInfoHeader) == 40);

    63

    64

struct RgbQuad {

    65

	byte blue, green, red, reserved;

    66

};

    67

assert_compile(sizeof(RgbQuad) == 4);

    68

    69

/* generic .BMP writer */

    70

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

    71

{

    72

	BitmapFileHeader bfh;

    73

	BitmapInfoHeader bih;

    74

	RgbQuad rq[256];

    75

	FILE *f;

    76

	uint i, padw;

    77

	uint n, maxlines;

    78

	uint pal_size = 0;

    79

	uint bpp = pixelformat / 8;

    80

    81

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

    82

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

    83

    84

	f = fopen(name, "wb");

    85

	if (f == NULL) return false;

    86

    87

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

    88

	padw = ALIGN(w, 4);

    89

    90

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

    91

    92

	/* setup the file header */

    93

	bfh.type = TO_LE16('MB');

    94

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

    95

	bfh.reserved = 0;

    96

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

    97

    98

	/* setup the info header */

    99

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

   100

	bih.width = TO_LE32(w);

   101

	bih.height = TO_LE32(h);

   102

	bih.planes = TO_LE16(1);

   103

	bih.bitcount = TO_LE16(pixelformat);

   104

	bih.compression = 0;

   105

	bih.sizeimage = 0;

   106

	bih.xpels = 0;

   107

	bih.ypels = 0;

   108

	bih.clrused = 0;

   109

	bih.clrimp = 0;

   110

   111

	if (pixelformat == 8) {

   112

		/* convert the palette to the windows format */

   113

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

   114

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

   115

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

   116

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

   117

			rq[i].reserved = 0;

   118

		}

   119

	}

   120

   121

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

   122

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

   123

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

   124

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

   125

   126

	/* use by default 64k temp memory */

   127

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

   128

   129

	/* now generate the bitmap bits */

   130

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

   131

	if (buff == NULL) {

   132

		fclose(f);

   133

		return false;

   134

	}

   135

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

   136

   137

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

   138

	do {

   139

		/* determine # lines */

   140

		n = min(h, maxlines);

   141

		h -= n;

   142

   143

		/* render the pixels */

   144

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

   145

   146

		/* write each line */

   147

		while (n)

   148

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

   149

				free(buff);

   150

				fclose(f);

   151

				return false;

   152

			}

   153

	} while (h != 0);

   154

   155

	free(buff);

   156

	fclose(f);

   157

   158

	return true;

   159

}

   160

   161

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

   162

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

   163

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

   164

#if defined(WITH_PNG)

   165

#include <png.h>

   166

   167

static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)

   168

{

   169

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

   170

	longjmp(png_ptr->jmpbuf, 1);

   171

}

   172

   173

static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)

   174

{

   175

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

   176

}

   177

   178

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

   179

{

   180

	png_color rq[256];

   181

	FILE *f;

   182

	uint i, y, n;

   183

	uint maxlines;

   184

	uint bpp = pixelformat / 8;

   185

	png_structp png_ptr;

   186

	png_infop info_ptr;

   187

   188

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

   189

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

   190

   191

	f = fopen(name, "wb");

   192

	if (f == NULL) return false;

   193

   194

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

   195

   196

	if (png_ptr == NULL) {

   197

		fclose(f);

   198

		return false;

   199

	}

   200

   201

	info_ptr = png_create_info_struct(png_ptr);

   202

	if (info_ptr == NULL) {

   203

		png_destroy_write_struct(&png_ptr, (png_infopp)NULL);

   204

		fclose(f);

   205

		return false;

   206

	}

   207

   208

	if (setjmp(png_jmpbuf(png_ptr))) {

   209

		png_destroy_write_struct(&png_ptr, &info_ptr);

   210

		fclose(f);

   211

		return false;

   212

	}

   213

   214

	png_init_io(png_ptr, f);

   215

   216

	png_set_filter(png_ptr, 0, PNG_FILTER_NONE);

   217

   218

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

   219

		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   220

   221

	if (pixelformat == 8) {

   222

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

   223

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

   224

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

   225

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

   226

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

   227

		}

   228

   229

		png_set_PLTE(png_ptr, info_ptr, rq, 256);

   230

	}

   231

   232

	png_write_info(png_ptr, info_ptr);

   233

	png_set_flush(png_ptr, 512);

   234

   235

	if (pixelformat == 32) {

   236

		png_color_8 sig_bit;

   237

   238

		/* Save exact color/alpha resolution */

   239

		sig_bit.alpha = 0;

   240

		sig_bit.blue  = 8;

   241

		sig_bit.green = 8;

   242

		sig_bit.red   = 8;

   243

		sig_bit.gray  = 8;

   244

		png_set_sBIT(png_ptr, info_ptr, &sig_bit);

   245

   246

#ifdef TTD_LITTLE_ENDIAN

   247

		png_set_bgr(png_ptr);

   248

		png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);

   249

#else

   250

		png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

   251

#endif

   252

	}

   253

   254

	/* use by default 64k temp memory */

   255

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

   256

   257

	/* now generate the bitmap bits */

   258

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

   259

	if (buff == NULL) {

   260

		png_destroy_write_struct(&png_ptr, &info_ptr);

   261

		fclose(f);

   262

		return false;

   263

	}

   264

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

   265

   266

	y = 0;

   267

	do {

   268

		/* determine # lines to write */

   269

		n = min(h - y, maxlines);

   270

   271

		/* render the pixels into the buffer */

   272

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

   273

		y += n;

   274

   275

		/* write them to png */

   276

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

   277

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

   278

	} while (y != h);

   279

   280

	png_write_end(png_ptr, info_ptr);

   281

	png_destroy_write_struct(&png_ptr, &info_ptr);

   282

   283

	free(buff);

   284

	fclose(f);

   285

	return true;

   286

}

   287

#endif /* WITH_PNG */

   288

   289

   290

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

   291

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

   292

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

   293

   294

struct PcxHeader {

   295

	byte manufacturer;

   296

	byte version;

   297

	byte rle;

   298

	byte bpp;

   299

	uint32 unused;

   300

	uint16 xmax, ymax;

   301

	uint16 hdpi, vdpi;

   302

	byte pal_small[16 * 3];

   303

	byte reserved;

   304

	byte planes;

   305

	uint16 pitch;

   306

	uint16 cpal;

   307

	uint16 width;

   308

	uint16 height;

   309

	byte filler[54];

   310

};

   311

assert_compile(sizeof(PcxHeader) == 128);

   312

   313

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

   314

{

   315

	FILE *f;

   316

	uint maxlines;

   317

	uint y;

   318

	PcxHeader pcx;

   319

	bool success;

   320

   321

	if (pixelformat == 32) {

   322

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

   323

		return false;

   324

	}

   325

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

   326

		return false;

   327

   328

	f = fopen(name, "wb");

   329

	if (f == NULL) return false;

   330

   331

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

   332

   333

	/* setup pcx header */

   334

	pcx.manufacturer = 10;

   335

	pcx.version = 5;

   336

	pcx.rle = 1;

   337

	pcx.bpp = 8;

   338

	pcx.xmax = TO_LE16(w - 1);

   339

	pcx.ymax = TO_LE16(h - 1);

   340

	pcx.hdpi = TO_LE16(320);

   341

	pcx.vdpi = TO_LE16(320);

   342

   343

	pcx.planes = 1;

   344

	pcx.cpal = TO_LE16(1);

   345

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

   346

	pcx.height = TO_LE16(h);

   347

   348

	/* write pcx header */

   349

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

   350

		fclose(f);

   351

		return false;

   352

	}

   353

   354

	/* use by default 64k temp memory */

   355

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

   356

   357

	/* now generate the bitmap bits */

   358

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

   359

	if (buff == NULL) {

   360

		fclose(f);

   361

		return false;

   362

	}

   363

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

   364

   365

	y = 0;

   366

	do {

   367

		/* determine # lines to write */

   368

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

   369

		uint i;

   370

   371

		/* render the pixels into the buffer */

   372

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

   373

		y += n;

   374

   375

		/* write them to pcx */

   376

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

   377

			const uint8 *bufp = buff + i * w;

   378

			byte runchar = bufp[0];

   379

			uint runcount = 1;

   380

			uint j;

   381

   382

			/* for each pixel... */

   383

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

   384

				uint8 ch = bufp[j];

   385

   386

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

   387

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

   388

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

   389

							free(buff);

   390

							fclose(f);

   391

							return false;

   392

						}

   393

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

   394

						free(buff);

   395

						fclose(f);

   396

						return false;

   397

					}

   398

					runcount = 0;

   399

					runchar = ch;

   400

				}

   401

				runcount++;

   402

			}

   403

   404

			/* write remaining bytes.. */

   405

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

   406

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

   407

					free(buff);

   408

					fclose(f);

   409

					return false;

   410

				}

   411

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

   412

				free(buff);

   413

				fclose(f);

   414

				return false;

   415

			}

   416

		}

   417

	} while (y != h);

   418

   419

	free(buff);

   420

   421

	/* write 8-bit color palette */

   422

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

   423

		fclose(f);

   424

		return false;

   425

	}

   426

   427

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

   428

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

   429

	} else {

   430

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

   431

		byte tmp[256 * 3];

   432

		uint i;

   433

   434

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

   435

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

   436

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

   437

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

   438

		}

   439

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

   440

	}

   441

   442

	fclose(f);

   443

   444

	return success;

   445

}

   446

   447

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

   448

//*** GENERIC SCREENSHOT CODE

   449

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

   450

   451

static const ScreenshotFormat _screenshot_formats[] = {

   452

#if defined(WITH_PNG)

   453

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

   454

#endif

   455

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

   456

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

   457

};

   458

   459

void InitializeScreenshotFormats()

   460

{

   461

	int i, j;

   462

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

   463

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

   464

			j = i;

   465

			break;

   466

		}

   467

	_cur_screenshot_format = j;

   468

	_num_screenshot_formats = lengthof(_screenshot_formats);

   469

	current_screenshot_type = SC_NONE;

   470

}

   471

   472

const char *GetScreenshotFormatDesc(int i)

   473

{

   474

	return _screenshot_formats[i].name;

   475

}

   476

   477

void SetScreenshotFormat(int i)

   478

{

   479

	_cur_screenshot_format = i;

   480

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

   481

}

   482

   483

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

   484

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

   485

{

   486

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   487

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

   488

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

   489

}

   490

   491

/* generate a large piece of the world */

   492

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

   493

{

   494

	ViewPort *vp = (ViewPort *)userdata;

   495

	DrawPixelInfo dpi, *old_dpi;

   496

	int wx, left;

   497

   498

	old_dpi = _cur_dpi;