/* $Id$ */ #include "stdafx.h" #include "openttd.h" #include "debug.h" #include "functions.h" #include "strings.h" #include "table/strings.h" #include "gfx.h" #include "hal.h" #include "viewport.h" #include "player.h" #include "screenshot.h" #include "variables.h" #include "date.h" #include "helpers.hpp" char _screenshot_format_name[8]; uint _num_screenshot_formats; uint _cur_screenshot_format; ScreenshotType current_screenshot_type; // called by the ScreenShot proc to generate screenshot lines. typedef void ScreenshotCallback(void *userdata, Pixel *buf, uint y, uint pitch, uint n); typedef bool ScreenshotHandlerProc(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette); typedef struct { const char *name; const char *extension; ScreenshotHandlerProc *proc; } ScreenshotFormat; //************************************************ //*** SCREENSHOT CODE FOR WINDOWS BITMAP (.BMP) //************************************************ #if defined(_MSC_VER) || defined(__WATCOMC__) #pragma pack(push, 1) #endif typedef struct BitmapFileHeader { uint16 type; uint32 size; uint32 reserved; uint32 off_bits; } GCC_PACK BitmapFileHeader; assert_compile(sizeof(BitmapFileHeader) == 14); #if defined(_MSC_VER) || defined(__WATCOMC__) #pragma pack(pop) #endif typedef struct BitmapInfoHeader { uint32 size; int32 width, height; uint16 planes, bitcount; uint32 compression, sizeimage, xpels, ypels, clrused, clrimp; } BitmapInfoHeader; assert_compile(sizeof(BitmapInfoHeader) == 40); typedef struct RgbQuad { byte blue, green, red, reserved; } RgbQuad; assert_compile(sizeof(RgbQuad) == 4); // generic .BMP writer static bool MakeBmpImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette) { BitmapFileHeader bfh; BitmapInfoHeader bih; RgbQuad rq[256]; FILE *f; uint i, padw; uint n, maxlines; // only implemented for 8bit images so far. if (pixelformat != 8) return false; f = fopen(name, "wb"); if (f == NULL) return false; // each scanline must be aligned on a 32bit boundary padw = ALIGN(w, 4); // setup the file header bfh.type = TO_LE16('MB'); bfh.size = TO_LE32(sizeof(bfh) + sizeof(bih) + sizeof(RgbQuad) * 256 + padw * h); bfh.reserved = 0; bfh.off_bits = TO_LE32(sizeof(bfh) + sizeof(bih) + sizeof(RgbQuad) * 256); // setup the info header bih.size = TO_LE32(sizeof(BitmapInfoHeader)); bih.width = TO_LE32(w); bih.height = TO_LE32(h); bih.planes = TO_LE16(1); bih.bitcount = TO_LE16(8); bih.compression = 0; bih.sizeimage = 0; bih.xpels = 0; bih.ypels = 0; bih.clrused = 0; bih.clrimp = 0; // convert the palette to the windows format for (i = 0; i != 256; i++) { rq[i].red = palette[i].r; rq[i].green = palette[i].g; rq[i].blue = palette[i].b; rq[i].reserved = 0; } // write file header and info header and palette if (fwrite(&bfh, sizeof(bfh), 1, f) != 1) return false; if (fwrite(&bih, sizeof(bih), 1, f) != 1) return false; if (fwrite(rq, sizeof(rq), 1, f) != 1) return false; // use by default 64k temp memory maxlines = clamp(65536 / padw, 16, 128); // now generate the bitmap bits Pixel *buff = MallocT<Pixel>(padw * maxlines); // by default generate 128 lines at a time. if (buff == NULL) { fclose(f); return false; } memset(buff, 0, padw * maxlines); // zero the buffer to have the padding bytes set to 0 // start at the bottom, since bitmaps are stored bottom up. do { // determine # lines n = min(h, maxlines); h -= n; // render the pixels callb(userdata, buff, h, padw, n); // write each line while (n) if (fwrite(buff + (--n) * padw, padw, 1, f) != 1) { free(buff); fclose(f); return false; } } while (h != 0); free(buff); fclose(f); return true; } //******************************************************** //*** SCREENSHOT CODE FOR PORTABLE NETWORK GRAPHICS (.PNG) //******************************************************** #if defined(WITH_PNG) #include <png.h> static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message) { DEBUG(misc, 0, "[libpng] error: %s - %s", message, (char *)png_get_error_ptr(png_ptr)); longjmp(png_ptr->jmpbuf, 1); } static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message) { DEBUG(misc, 1, "[libpng] warning: %s - %s", message, (char *)png_get_error_ptr(png_ptr)); } static bool MakePNGImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette) { png_color rq[256]; FILE *f; uint i, y, n; uint maxlines; png_structp png_ptr; png_infop info_ptr; // only implemented for 8bit images so far. if (pixelformat != 8) return false; f = fopen(name, "wb"); if (f == NULL) return false; png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (char *)name, png_my_error, png_my_warning); if (png_ptr == NULL) { fclose(f); return false; } info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { png_destroy_write_struct(&png_ptr, (png_infopp)NULL); fclose(f); return false; } if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_write_struct(&png_ptr, &info_ptr); fclose(f); return false; } png_init_io(png_ptr, f); png_set_filter(png_ptr, 0, PNG_FILTER_NONE); png_set_IHDR(png_ptr, info_ptr, w, h, pixelformat, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); // convert the palette to the .PNG format. for (i = 0; i != 256; i++) { rq[i].red = palette[i].r; rq[i].green = palette[i].g; rq[i].blue = palette[i].b; } png_set_PLTE(png_ptr, info_ptr, rq, 256); png_write_info(png_ptr, info_ptr); png_set_flush(png_ptr, 512); // use by default 64k temp memory maxlines = clamp(65536 / w, 16, 128); // now generate the bitmap bits Pixel *buff = MallocT<Pixel>(w * maxlines); // by default generate 128 lines at a time. if (buff == NULL) { png_destroy_write_struct(&png_ptr, &info_ptr); fclose(f); return false; } memset(buff, 0, w * maxlines); // zero the buffer to have the padding bytes set to 0 y = 0; do { // determine # lines to write n = min(h - y, maxlines); // render the pixels into the buffer callb(userdata, buff, y, w, n); y += n; // write them to png for (i = 0; i != n; i++) png_write_row(png_ptr, buff + i * w); } while (y != h); png_write_end(png_ptr, info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr); free(buff); fclose(f); return true; } #endif /* WITH_PNG */ //************************************************ //*** SCREENSHOT CODE FOR ZSOFT PAINTBRUSH (.PCX) //************************************************ typedef struct { byte manufacturer; byte version; byte rle; byte bpp; uint32 unused; uint16 xmax, ymax; uint16 hdpi, vdpi; byte pal_small[16*3]; byte reserved; byte planes; uint16 pitch; uint16 cpal; uint16 width; uint16 height; byte filler[54]; } PcxHeader; assert_compile(sizeof(PcxHeader) == 128); static bool MakePCXImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette) { FILE *f; uint maxlines; uint y; PcxHeader pcx; bool success; if (pixelformat != 8 || w == 0) return false; f = fopen(name, "wb"); if (f == NULL) return false; memset(&pcx, 0, sizeof(pcx)); // setup pcx header pcx.manufacturer = 10; pcx.version = 5; pcx.rle = 1; pcx.bpp = 8; pcx.xmax = TO_LE16(w - 1); pcx.ymax = TO_LE16(h - 1); pcx.hdpi = TO_LE16(320); pcx.vdpi = TO_LE16(320); pcx.planes = 1; pcx.cpal = TO_LE16(1); pcx.width = pcx.pitch = TO_LE16(w); pcx.height = TO_LE16(h); // write pcx header if (fwrite(&pcx, sizeof(pcx), 1, f) != 1) { fclose(f); return false; } // use by default 64k temp memory maxlines = clamp(65536 / w, 16, 128); // now generate the bitmap bits Pixel *buff = MallocT<Pixel>(w * maxlines); // by default generate 128 lines at a time. if (buff == NULL) { fclose(f); return false; } memset(buff, 0, w * maxlines); // zero the buffer to have the padding bytes set to 0 y = 0; do { // determine # lines to write uint n = min(h - y, maxlines); uint i; // render the pixels into the buffer callb(userdata, buff, y, w, n); y += n; // write them to pcx for (i = 0; i != n; i++) { const Pixel* bufp = buff + i * w; byte runchar = bufp[0]; uint runcount = 1; uint j; // for each pixel... for (j = 1; j < w; j++) { Pixel ch = bufp[j]; if (ch != runchar || runcount >= 0x3f) { if (runcount > 1 || (runchar & 0xC0) == 0xC0) if (fputc(0xC0 | runcount, f) == EOF) { free(buff); fclose(f); return false; } if (fputc(runchar, f) == EOF) { free(buff); fclose(f); return false; } runcount = 0; runchar = ch; } runcount++; } // write remaining bytes.. if (runcount > 1 || (runchar & 0xC0) == 0xC0) if (fputc(0xC0 | runcount, f) == EOF) { free(buff); fclose(f); return false; } if (fputc(runchar, f) == EOF) { free(buff); fclose(f); return false; } } } while (y != h); free(buff); // write 8-bit color palette if (fputc(12, f) == EOF) { fclose(f); return false; } if (sizeof(*palette) == 3) { success = fwrite(palette, 256 * sizeof(*palette), 1, f) == 1; } else { /* If the palette is word-aligned, copy it to a temporary byte array */ byte tmp[256 * 3]; uint i; for (i = 0; i < 256; i++) { tmp[i * 3 + 0] = palette[i].r; tmp[i * 3 + 1] = palette[i].g; tmp[i * 3 + 2] = palette[i].b; } success = fwrite(tmp, sizeof(tmp), 1, f) == 1; } fclose(f); return success; } //************************************************ //*** GENERIC SCREENSHOT CODE //************************************************ static const ScreenshotFormat _screenshot_formats[] = { #if defined(WITH_PNG) {"PNG", "png", &MakePNGImage}, #endif {"BMP", "bmp", &MakeBmpImage}, {"PCX", "pcx", &MakePCXImage}, }; void InitializeScreenshotFormats(void) { int i, j; for (i = 0, j = 0; i != lengthof(_screenshot_formats); i++) if (!strcmp(_screenshot_format_name, _screenshot_formats[i].extension)) { j = i; break; } _cur_screenshot_format = j; _num_screenshot_formats = lengthof(_screenshot_formats); current_screenshot_type = SC_NONE; } const char *GetScreenshotFormatDesc(int i) { return _screenshot_formats[i].name; } void SetScreenshotFormat(int i) { _cur_screenshot_format = i; strcpy(_screenshot_format_name, _screenshot_formats[i].extension); } // screenshot generator that dumps the current video buffer static void CurrentScreenCallback(void *userdata, Pixel *buf, uint y, uint pitch, uint n) { for (; n > 0; --n) { memcpy(buf, _screen.dst_ptr + y * _screen.pitch, _screen.width); ++y; buf += pitch; } } // generate a large piece of the world static void LargeWorldCallback(void *userdata, Pixel *buf, uint y, uint pitch, uint n) { ViewPort *vp = (ViewPort *)userdata; DrawPixelInfo dpi, *old_dpi; int wx, left; old_dpi = _cur_dpi; _cur_dpi = &dpi; dpi.dst_ptr = buf; dpi.height = n; dpi.width = vp->width; dpi.pitch = pitch; dpi.zoom = 0; dpi.left = 0; dpi.top = y; left = 0; while (vp->width - left != 0) { wx = min(vp->width - left, 1600); left += wx; ViewportDoDraw(vp, ((left - wx - vp->left) << vp->zoom) + vp->virtual_left, ((y - vp->top) << vp->zoom) + vp->virtual_top, ((left - vp->left) << vp->zoom) + vp->virtual_left, (((y + n) - vp->top) << vp->zoom) + vp->virtual_top ); } _cur_dpi = old_dpi; } static char *MakeScreenshotName(const char *ext) { static char filename[256]; char *base; int serial; if (_game_mode == GM_EDITOR || _game_mode == GM_MENU || _local_player == PLAYER_SPECTATOR) { sprintf(_screenshot_name, "screenshot"); } else { const Player* p = GetPlayer(_local_player); SetDParam(0, p->name_1); SetDParam(1, p->name_2); SetDParam(2, _date); GetString(_screenshot_name, STR_4004, lastof(_screenshot_name)); } base = strchr(_screenshot_name, 0); base[0] = '.'; strcpy(base + 1, ext); serial = 0; for (;;) { snprintf(filename, sizeof(filename), "%s%s", _paths.personal_dir, _screenshot_name); if (!FileExists(filename)) break; sprintf(base, " #%d.%s", ++serial, ext); } return filename; } void SetScreenshotType(ScreenshotType t) { current_screenshot_type = t; } bool IsScreenshotRequested(void) { return (current_screenshot_type != SC_NONE); } static bool MakeSmallScreenshot(void) { const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format; return sf->proc(MakeScreenshotName(sf->extension), CurrentScreenCallback, NULL, _screen.width, _screen.height, 8, _cur_palette); } static bool MakeWorldScreenshot(void) { ViewPort vp; const ScreenshotFormat *sf; vp.zoom = 0; vp.left = 0; vp.top = 0; vp.virtual_left = -(int)MapMaxX() * TILE_PIXELS; vp.virtual_top = 0; vp.virtual_width = (MapMaxX() + MapMaxY()) * TILE_PIXELS; vp.width = vp.virtual_width; vp.virtual_height = (MapMaxX() + MapMaxY()) * TILE_PIXELS >> 1; vp.height = vp.virtual_height; sf = _screenshot_formats + _cur_screenshot_format; return sf->proc(MakeScreenshotName(sf->extension), LargeWorldCallback, &vp, vp.width, vp.height, 8, _cur_palette); } bool MakeScreenshot(void) { switch (current_screenshot_type) { case SC_VIEWPORT: UndrawMouseCursor(); DrawDirtyBlocks(); current_screenshot_type = SC_NONE; return MakeSmallScreenshot(); case SC_WORLD: current_screenshot_type = SC_NONE; return MakeWorldScreenshot(); default: return false; } }