screenshot.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "core/backup_type.hpp"
#include "fileio_func.h"
#include "viewport_func.h"
#include "gfx_func.h"
#include "screenshot.h"
#include "screenshot_gui.h"
#include "blitter/factory.hpp"
#include "zoom_func.h"
#include "core/endian_func.hpp"
#include "saveload/saveload.h"
#include "company_base.h"
#include "company_func.h"
#include "strings_func.h"
#include "error.h"
#include "textbuf_gui.h"
#include "window_gui.h"
#include "window_func.h"
#include "tile_map.h"
#include "landscape.h"
#include "video/video_driver.hpp"
#include "smallmap_gui.h"
 
#include "table/strings.h"
 
#include "safeguards.h"
 
static const char * const SCREENSHOT_NAME = "screenshot"; 
static const char * const HEIGHTMAP_NAME  = "heightmap";  
 
std::string _screenshot_format_name;  
static std::string _screenshot_name;  
std::string _full_screenshot_path;    
uint _heightmap_highest_peak;         
 
typedef void ScreenshotCallback(void *userdata, void *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);
 
struct ScreenshotFormat {
  const char *extension;       
  ScreenshotHandlerProc *proc; 
};
 
#define MKCOLOUR(x)         TO_LE32(x)
 
/*************************************************
 **** SCREENSHOT CODE FOR WINDOWS BITMAP (.BMP)
 *************************************************/
 
PACK(struct BitmapFileHeader {
  uint16_t type;
  uint32_t size;
  uint32_t reserved;
  uint32_t off_bits;
});
static_assert(sizeof(BitmapFileHeader) == 14);
 
struct BitmapInfoHeader {
  uint32_t size;
  int32_t width, height;
  uint16_t planes, bitcount;
  uint32_t compression, sizeimage, xpels, ypels, clrused, clrimp;
};
static_assert(sizeof(BitmapInfoHeader) == 40);
 
struct RgbQuad {
  uint8_t blue, green, red, reserved;
};
static_assert(sizeof(RgbQuad) == 4);
 
static bool MakeBMPImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
{
  uint bpp; // bytes per pixel
  switch (pixelformat) {
    case 8:  bpp = 1; break;
    /* 32bpp mode is saved as 24bpp BMP */
    case 32: bpp = 3; break;
    /* Only implemented for 8bit and 32bit images so far */
    default: return false;
  }
 
  auto of = FileHandle::Open(name, "wb");
  if (!of.has_value()) return false;
  auto &f = *of;
 
  /* Each scanline must be aligned on a 32bit boundary */
  uint bytewidth = Align(w * bpp, 4); // bytes per line in file
 
  /* Size of palette. Only present for 8bpp mode */
  uint pal_size = pixelformat == 8 ? sizeof(RgbQuad) * 256 : 0;
 
  /* Setup the file header */
  BitmapFileHeader bfh;
  bfh.type = TO_LE16('MB');
  bfh.size = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size + static_cast<size_t>(bytewidth) * h);
  bfh.reserved = 0;
  bfh.off_bits = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size);
 
  /* Setup the info header */
  BitmapInfoHeader bih;
  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(bpp * 8);
  bih.compression = 0;
  bih.sizeimage = 0;
  bih.xpels = 0;
  bih.ypels = 0;
  bih.clrused = 0;
  bih.clrimp = 0;
 
  /* Write file header and info header */
  if (fwrite(&bfh, sizeof(bfh), 1, f) != 1 || fwrite(&bih, sizeof(bih), 1, f) != 1) {
    return false;
  }
 
  if (pixelformat == 8) {
    /* Convert the palette to the windows format */
    RgbQuad rq[256];
    for (uint 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 the palette */
    if (fwrite(rq, sizeof(rq), 1, f) != 1) {
      return false;
    }
  }
 
  /* Try to use 64k of memory, store between 16 and 128 lines */
  uint maxlines = Clamp(65536 / (w * pixelformat / 8), 16, 128); // number of lines per iteration
 
  std::vector<uint8_t> buff(maxlines * w * pixelformat / 8); // buffer which is rendered to
  std::vector<uint8_t> line(bytewidth); // one line, stored to file
 
  /* Start at the bottom, since bitmaps are stored bottom up */
  do {
    uint n = std::min(h, maxlines);
    h -= n;
 
    /* Render the pixels */
    callb(userdata, buff.data(), h, w, n);
 
    /* Write each line */
    while (n-- != 0) {
      if (pixelformat == 8) {
        /* Move to 'line', leave last few pixels in line zeroed */
        memcpy(line.data(), buff.data() + n * w, w);
      } else {
        /* Convert from 'native' 32bpp to BMP-like 24bpp.
         * Works for both big and little endian machines */
        Colour *src = ((Colour *)buff.data()) + n * w;
        uint8_t *dst = line.data();
        for (uint i = 0; i < w; i++) {
          dst[i * 3    ] = src[i].b;
          dst[i * 3 + 1] = src[i].g;
          dst[i * 3 + 2] = src[i].r;
        }
      }
      /* Write to file */
      if (fwrite(line.data(), bytewidth, 1, f) != 1) {
        return false;
      }
    }
  } while (h != 0);
 
 
  return true;
}
 
/*********************************************************
 **** SCREENSHOT CODE FOR PORTABLE NETWORK GRAPHICS (.PNG)
 *********************************************************/
#if defined(WITH_PNG)
#include <png.h>
 
#ifdef PNG_TEXT_SUPPORTED
#include "rev.h"
#include "newgrf_config.h"
#include "ai/ai_info.hpp"
#include "company_base.h"
#include "base_media_base.h"
#endif /* PNG_TEXT_SUPPORTED */
 
static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)
{
  Debug(misc, 0, "[libpng] error: {} - {}", message, (const char *)png_get_error_ptr(png_ptr));
  longjmp(png_jmpbuf(png_ptr), 1);
}
 
static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)
{
  Debug(misc, 1, "[libpng] warning: {} - {}", message, (const 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];
  uint i, y, n;
  uint maxlines;
  uint bpp = pixelformat / 8;
  png_structp png_ptr;
  png_infop info_ptr;
 
  /* only implemented for 8bit and 32bit images so far. */
  if (pixelformat != 8 && pixelformat != 32) return false;
 
  auto of = FileHandle::Open(name, "wb");
  if (!of.has_value()) return false;
  auto &f = *of;
 
  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, const_cast<char *>(name), png_my_error, png_my_warning);
 
  if (png_ptr == nullptr) {
    return false;
  }
 
  info_ptr = png_create_info_struct(png_ptr);
  if (info_ptr == nullptr) {
    png_destroy_write_struct(&png_ptr, (png_infopp)nullptr);
    return false;
  }
 
  if (setjmp(png_jmpbuf(png_ptr))) {
    png_destroy_write_struct(&png_ptr, &info_ptr);
    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, 8, pixelformat == 8 ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_RGB,
    PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
#ifdef PNG_TEXT_SUPPORTED
  /* Try to add some game metadata to the PNG screenshot so
   * it's more useful for debugging and archival purposes. */
  png_text_struct text[2];
  memset(text, 0, sizeof(text));
  text[0].key = const_cast<char *>("Software");
  text[0].text = const_cast<char *>(_openttd_revision);
  text[0].text_length = strlen(_openttd_revision);
  text[0].compression = PNG_TEXT_COMPRESSION_NONE;
 
  std::string message;
  message.reserve(1024);
  fmt::format_to(std::back_inserter(message), "Graphics set: {} ({})\n", BaseGraphics::GetUsedSet()->name, BaseGraphics::GetUsedSet()->version);
  message += "NewGRFs:\n";
  for (const GRFConfig *c = _game_mode == GM_MENU ? nullptr : _grfconfig; c != nullptr; c = c->next) {
    fmt::format_to(std::back_inserter(message), "{:08X} {} {}\n", BSWAP32(c->ident.grfid), FormatArrayAsHex(c->ident.md5sum), c->filename);
  }
  message += "\nCompanies:\n";
  for (const Company *c : Company::Iterate()) {
    if (c->ai_info == nullptr) {
      fmt::format_to(std::back_inserter(message), "{:2d}: Human\n", (int)c->index);
    } else {
      fmt::format_to(std::back_inserter(message), "{:2d}: {} (v{})\n", (int)c->index, c->ai_info->GetName(), c->ai_info->GetVersion());
    }
  }
  text[1].key = const_cast<char *>("Description");
  text[1].text = const_cast<char *>(message.c_str());
  text[1].text_length = message.size();
  text[1].compression = PNG_TEXT_COMPRESSION_zTXt;
  png_set_text(png_ptr, info_ptr, text, 2);
#endif /* PNG_TEXT_SUPPORTED */
 
  if (pixelformat == 8) {
    /* 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);
 
  if (pixelformat == 32) {
    png_color_8 sig_bit;
 
    /* Save exact colour/alpha resolution */
    sig_bit.alpha = 0;
    sig_bit.blue  = 8;
    sig_bit.green = 8;
    sig_bit.red   = 8;
    sig_bit.gray  = 8;
    png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 
    if constexpr (std::endian::native == std::endian::little) {
      png_set_bgr(png_ptr);
      png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
    } else {
      png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
    }
  }
 
  /* use by default 64k temp memory */
  maxlines = Clamp(65536 / w, 16, 128);
 
  /* now generate the bitmap bits */
  std::vector<uint8_t> buff(static_cast<size_t>(w) * maxlines * bpp); // by default generate 128 lines at a time.
 
  y = 0;
  do {
    /* determine # lines to write */
    n = std::min(h - y, maxlines);
 
    /* render the pixels into the buffer */
    callb(userdata, buff.data(), y, w, n);
    y += n;
 
    /* write them to png */
    for (i = 0; i != n; i++) {
      png_write_row(png_ptr, (png_bytep)buff.data() + i * w * bpp);
    }
  } while (y != h);
 
  png_write_end(png_ptr, info_ptr);
  png_destroy_write_struct(&png_ptr, &info_ptr);
 
  return true;
}
#endif /* WITH_PNG */
 
 
/*************************************************
 **** SCREENSHOT CODE FOR ZSOFT PAINTBRUSH (.PCX)
 *************************************************/
 
struct PcxHeader {
  uint8_t manufacturer;
  uint8_t version;
  uint8_t rle;
  uint8_t bpp;
  uint32_t unused;
  uint16_t xmax, ymax;
  uint16_t hdpi, vdpi;
  uint8_t pal_small[16 * 3];
  uint8_t reserved;
  uint8_t planes;
  uint16_t pitch;
  uint16_t cpal;
  uint16_t width;
  uint16_t height;
  uint8_t filler[54];
};
static_assert(sizeof(PcxHeader) == 128);
 
static bool MakePCXImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
{
  uint maxlines;
  uint y;
  PcxHeader pcx;
  bool success;
 
  if (pixelformat == 32) {
    Debug(misc, 0, "Can't convert a 32bpp screenshot to PCX format. Please pick another format.");
    return false;
  }
  if (pixelformat != 8 || w == 0) return false;
 
  auto of = FileHandle::Open(name, "wb");
  if (!of.has_value()) return false;
  auto &f = *of;
 
  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) {
    return false;
  }
 
  /* use by default 64k temp memory */
  maxlines = Clamp(65536 / w, 16, 128);
 
  /* now generate the bitmap bits */
  std::vector<uint8_t> buff(static_cast<size_t>(w) * maxlines); // by default generate 128 lines at a time.
 
  y = 0;
  do {
    /* determine # lines to write */
    uint n = std::min(h - y, maxlines);
    uint i;
 
    /* render the pixels into the buffer */
    callb(userdata, buff.data(), y, w, n);
    y += n;
 
    /* write them to pcx */
    for (i = 0; i != n; i++) {
      const uint8_t *bufp = buff.data() + i * w;
      uint8_t runchar = bufp[0];
      uint runcount = 1;
      uint j;
 
      /* for each pixel... */
      for (j = 1; j < w; j++) {
        uint8_t ch = bufp[j];
 
        if (ch != runchar || runcount >= 0x3f) {
          if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
            if (fputc(0xC0 | runcount, f) == EOF) {
              return false;
            }
          }
          if (fputc(runchar, f) == EOF) {
            return false;
          }
          runcount = 0;
          runchar = ch;
        }
        runcount++;
      }
 
      /* write remaining bytes.. */
      if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
        if (fputc(0xC0 | runcount, f) == EOF) {
          return false;
        }
      }
      if (fputc(runchar, f) == EOF) {
        return false;
      }
    }
  } while (y != h);
 
  /* write 8-bit colour palette */
  if (fputc(12, f) == EOF) {
    return false;
  }
 
  /* Palette is word-aligned, copy it to a temporary byte array */
  uint8_t tmp[256 * 3];
 
  for (uint 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;
 
  return success;
}
 
/*************************************************
 **** GENERIC SCREENSHOT CODE
 *************************************************/
 
static const ScreenshotFormat _screenshot_formats[] = {
#if defined(WITH_PNG)
  {"png", &MakePNGImage},
#endif
  {"bmp", &MakeBMPImage},
  {"pcx", &MakePCXImage},
};
 
/* The currently loaded screenshot format. Set to a valid value as it might be used in early crash logs, when InitializeScreenshotFormats has not been called yet. */
static const ScreenshotFormat *_cur_screenshot_format = std::begin(_screenshot_formats);
 
const char *GetCurrentScreenshotExtension()
{
  return _cur_screenshot_format->extension;
}
 
void InitializeScreenshotFormats()
{
  for (auto &format : _screenshot_formats) {
    if (_screenshot_format_name == format.extension) {
      _cur_screenshot_format = &format;
      return;
    }
  }
 
  _cur_screenshot_format = std::begin(_screenshot_formats);
}
 
static void CurrentScreenCallback(void *, void *buf, uint y, uint pitch, uint n)
{
  Blitter *blitter = BlitterFactory::GetCurrentBlitter();
  void *src = blitter->MoveTo(_screen.dst_ptr, 0, y);
  blitter->CopyImageToBuffer(src, buf, _screen.width, n, pitch);
}
 
static void LargeWorldCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
{
  Viewport *vp = (Viewport *)userdata;
  DrawPixelInfo dpi;
  int wx, left;
 
  /* We are no longer rendering to the screen */
  DrawPixelInfo old_screen = _screen;
  bool old_disable_anim = _screen_disable_anim;
 
  _screen.dst_ptr = buf;
  _screen.width = pitch;
  _screen.height = n;
  _screen.pitch = pitch;
  _screen_disable_anim = true;
 
  AutoRestoreBackup dpi_backup(_cur_dpi, &dpi);
 
  dpi.dst_ptr = buf;
  dpi.height = n;
  dpi.width = vp->width;
  dpi.pitch = pitch;
  dpi.zoom = ZOOM_LVL_WORLD_SCREENSHOT;
  dpi.left = 0;
  dpi.top = y;
 
  /* Render viewport in blocks of 1600 pixels width */
  left = 0;
  while (vp->width - left != 0) {
    wx = std::min(vp->width - left, 1600);
    left += wx;
 
    ViewportDoDraw(vp,
      ScaleByZoom(left - wx - vp->left, vp->zoom) + vp->virtual_left,
      ScaleByZoom(y - vp->top, vp->zoom) + vp->virtual_top,
      ScaleByZoom(left - vp->left, vp->zoom) + vp->virtual_left,
      ScaleByZoom((y + n) - vp->top, vp->zoom) + vp->virtual_top
    );
  }
 
  /* Switch back to rendering to the screen */
  _screen = old_screen;
  _screen_disable_anim = old_disable_anim;
}
 
static const char *MakeScreenshotName(const char *default_fn, const char *ext, bool crashlog = false)
{
  bool generate = _screenshot_name.empty();
 
  if (generate) {
    if (_game_mode == GM_EDITOR || _game_mode == GM_MENU || _local_company == COMPANY_SPECTATOR) {
      _screenshot_name = default_fn;
    } else {
      _screenshot_name = GenerateDefaultSaveName();
    }
  }
 
  /* Handle user-specified filenames ending in # with automatic numbering */
  if (_screenshot_name.ends_with("#")) {
    generate = true;
    _screenshot_name.pop_back();
  }
 
  size_t len = _screenshot_name.size();
  /* Add extension to screenshot file */
  _screenshot_name += fmt::format(".{}", ext);
 
  const char *screenshot_dir = crashlog ? _personal_dir.c_str() : FiosGetScreenshotDir();
 
  for (uint serial = 1;; serial++) {
    _full_screenshot_path = fmt::format("{}{}", screenshot_dir, _screenshot_name);
 
    if (!generate) break; // allow overwriting of non-automatic filenames
    if (!FileExists(_full_screenshot_path)) break;
    /* If file exists try another one with same name, but just with a higher index */
    _screenshot_name.erase(len);
    _screenshot_name += fmt::format("#{}.{}", serial, ext);
  }
 
  return _full_screenshot_path.c_str();
}
 
static bool MakeSmallScreenshot(bool crashlog)
{
  return _cur_screenshot_format->proc(MakeScreenshotName(SCREENSHOT_NAME, _cur_screenshot_format->extension, crashlog), CurrentScreenCallback, nullptr, _screen.width, _screen.height,
      BlitterFactory::GetCurrentBlitter()->GetScreenDepth(), _cur_palette.palette);
}
 
void SetupScreenshotViewport(ScreenshotType t, Viewport *vp, uint32_t width, uint32_t height)
{
  switch(t) {
    case SC_VIEWPORT:
    case SC_CRASHLOG: {
      assert(width == 0 && height == 0);
 
      Window *w = GetMainWindow();
      vp->virtual_left   = w->viewport->virtual_left;
      vp->virtual_top    = w->viewport->virtual_top;
      vp->virtual_width  = w->viewport->virtual_width;
      vp->virtual_height = w->viewport->virtual_height;
 
      /* Compute pixel coordinates */
      vp->left = 0;
      vp->top = 0;
      vp->width = _screen.width;
      vp->height = _screen.height;
      vp->overlay = w->viewport->overlay;
      break;
    }
    case SC_WORLD: {
      assert(width == 0 && height == 0);
 
      /* Determine world coordinates of screenshot */
      vp->zoom = ZOOM_LVL_WORLD_SCREENSHOT;
 
      TileIndex north_tile = _settings_game.construction.freeform_edges ? TileXY(1, 1) : TileXY(0, 0);
      TileIndex south_tile = Map::Size() - 1;
 
      /* We need to account for a hill or high building at tile 0,0. */
      int extra_height_top = TilePixelHeight(north_tile) + 150;
      /* If there is a hill at the bottom don't create a large black area. */
      int reclaim_height_bottom = TilePixelHeight(south_tile);
 
      vp->virtual_left   = RemapCoords(TileX(south_tile) * TILE_SIZE, TileY(north_tile) * TILE_SIZE, 0).x;
      vp->virtual_top    = RemapCoords(TileX(north_tile) * TILE_SIZE, TileY(north_tile) * TILE_SIZE, extra_height_top).y;
      vp->virtual_width  = RemapCoords(TileX(north_tile) * TILE_SIZE, TileY(south_tile) * TILE_SIZE, 0).x                     - vp->virtual_left + 1;
      vp->virtual_height = RemapCoords(TileX(south_tile) * TILE_SIZE, TileY(south_tile) * TILE_SIZE, reclaim_height_bottom).y - vp->virtual_top  + 1;
 
      /* Compute pixel coordinates */
      vp->left = 0;
      vp->top = 0;
      vp->width  = UnScaleByZoom(vp->virtual_width,  vp->zoom);
      vp->height = UnScaleByZoom(vp->virtual_height, vp->zoom);
      vp->overlay = nullptr;
      break;
    }
    default: {
      vp->zoom = (t == SC_ZOOMEDIN) ? _settings_client.gui.zoom_min : ZOOM_LVL_VIEWPORT;
 
      Window *w = GetMainWindow();
      vp->virtual_left   = w->viewport->virtual_left;
      vp->virtual_top    = w->viewport->virtual_top;
 
      if (width == 0 || height == 0) {
        vp->virtual_width  = w->viewport->virtual_width;
        vp->virtual_height = w->viewport->virtual_height;
      } else {
        vp->virtual_width = width << vp->zoom;
        vp->virtual_height = height << vp->zoom;
      }
 
      /* Compute pixel coordinates */
      vp->left = 0;
      vp->top = 0;
      vp->width  = UnScaleByZoom(vp->virtual_width,  vp->zoom);
      vp->height = UnScaleByZoom(vp->virtual_height, vp->zoom);
      vp->overlay = nullptr;
      break;
    }
  }
}
 
static bool MakeLargeWorldScreenshot(ScreenshotType t, uint32_t width = 0, uint32_t height = 0)
{
  Viewport vp;
  SetupScreenshotViewport(t, &vp, width, height);
 
  return _cur_screenshot_format->proc(MakeScreenshotName(SCREENSHOT_NAME, _cur_screenshot_format->extension), LargeWorldCallback, &vp, vp.width, vp.height,
      BlitterFactory::GetCurrentBlitter()->GetScreenDepth(), _cur_palette.palette);
}
 
static void HeightmapCallback(void *, void *buffer, uint y, uint, uint n)
{
  uint8_t *buf = (uint8_t *)buffer;
  while (n > 0) {
    TileIndex ti = TileXY(Map::MaxX(), y);
    for (uint x = Map::MaxX(); true; x--) {
      *buf = 256 * TileHeight(ti) / (1 + _heightmap_highest_peak);
      buf++;
      if (x == 0) break;
      ti = TileAddXY(ti, -1, 0);
    }
    y++;
    n--;
  }
}
 
bool MakeHeightmapScreenshot(const char *filename)
{
  Colour palette[256];
  for (uint i = 0; i < lengthof(palette); i++) {
    palette[i].a = 0xff;
    palette[i].r = i;
    palette[i].g = i;
    palette[i].b = i;
  }
 
  _heightmap_highest_peak = 0;
  for (TileIndex tile = 0; tile < Map::Size(); tile++) {
    uint h = TileHeight(tile);
    _heightmap_highest_peak = std::max(h, _heightmap_highest_peak);
  }
 
  return _cur_screenshot_format->proc(filename, HeightmapCallback, nullptr, Map::SizeX(), Map::SizeY(), 8, palette);
}
 
static ScreenshotType _confirmed_screenshot_type; 
 
static void ScreenshotConfirmationCallback(Window *, bool confirmed)
{
  if (confirmed) MakeScreenshot(_confirmed_screenshot_type, {});
}
 
void MakeScreenshotWithConfirm(ScreenshotType t)
{
  Viewport vp;
  SetupScreenshotViewport(t, &vp);
 
  bool heightmap_or_minimap = t == SC_HEIGHTMAP || t == SC_MINIMAP;
  uint64_t width = (heightmap_or_minimap ? Map::SizeX() : vp.width);
  uint64_t height = (heightmap_or_minimap ? Map::SizeY() : vp.height);
 
  if (width * height > 8192 * 8192) {
    /* Ask for confirmation */
    _confirmed_screenshot_type = t;
    SetDParam(0, width);
    SetDParam(1, height);
    ShowQuery(STR_WARNING_SCREENSHOT_SIZE_CAPTION, STR_WARNING_SCREENSHOT_SIZE_MESSAGE, nullptr, ScreenshotConfirmationCallback);
  } else {
    /* Less than 64M pixels, just do it */
    MakeScreenshot(t, {});
  }
}
 
static bool RealMakeScreenshot(ScreenshotType t, std::string name, uint32_t width, uint32_t height)
{
  if (t == SC_VIEWPORT) {
    /* First draw the dirty parts of the screen and only then change the name
     * of the screenshot. This way the screenshot will always show the name
     * of the previous screenshot in the 'successful' message instead of the
     * name of the new screenshot (or an empty name). */
    SetScreenshotWindowVisibility(true);
    UndrawMouseCursor();
    DrawDirtyBlocks();
    SetScreenshotWindowVisibility(false);
  }
 
  _screenshot_name = name;
 
  bool ret;
  switch (t) {
    case SC_VIEWPORT:
      ret = MakeSmallScreenshot(false);
      break;
 
    case SC_CRASHLOG:
      ret = MakeSmallScreenshot(true);
      break;
 
    case SC_ZOOMEDIN:
    case SC_DEFAULTZOOM:
      ret = MakeLargeWorldScreenshot(t, width, height);
      break;
 
    case SC_WORLD:
      ret = MakeLargeWorldScreenshot(t);
      break;
 
    case SC_HEIGHTMAP: {
      ret = MakeHeightmapScreenshot(MakeScreenshotName(HEIGHTMAP_NAME, _cur_screenshot_format->extension));
      break;
    }
 
    case SC_MINIMAP:
      ret = MakeMinimapWorldScreenshot();
      break;
 
    default:
      NOT_REACHED();
  }
 
  if (ret) {
    if (t == SC_HEIGHTMAP) {
      SetDParamStr(0, _screenshot_name);
      SetDParam(1, _heightmap_highest_peak);
      ShowErrorMessage(STR_MESSAGE_HEIGHTMAP_SUCCESSFULLY, INVALID_STRING_ID, WL_WARNING);
    } else {
      SetDParamStr(0, _screenshot_name);
      ShowErrorMessage(STR_MESSAGE_SCREENSHOT_SUCCESSFULLY, INVALID_STRING_ID, WL_WARNING);
    }
  } else {
    ShowErrorMessage(STR_ERROR_SCREENSHOT_FAILED, INVALID_STRING_ID, WL_ERROR);
  }
 
  return ret;
}
 
bool MakeScreenshot(ScreenshotType t, std::string name, uint32_t width, uint32_t height)
{
  if (t == SC_CRASHLOG) {
    /* Video buffer might or might not be locked. */
    VideoDriver::VideoBufferLocker lock;
 
    return RealMakeScreenshot(t, name, width, height);
  }
 
  VideoDriver::GetInstance()->QueueOnMainThread([=] { // Capture by value to not break scope.
    RealMakeScreenshot(t, name, width, height);
  });
 
  return true;
}
 
 
static void MinimapScreenCallback(void *, void *buf, uint y, uint pitch, uint n)
{
  uint32_t *ubuf = (uint32_t *)buf;
  uint num = (pitch * n);
  for (uint i = 0; i < num; i++) {
    uint row = y + (int)(i / pitch);
    uint col = (Map::SizeX() - 1) - (i % pitch);
 
    TileIndex tile = TileXY(col, row);
    uint8_t val = GetSmallMapOwnerPixels(tile, GetTileType(tile), IncludeHeightmap::Never) & 0xFF;
 
    uint32_t colour_buf = 0;
    colour_buf  = (_cur_palette.palette[val].b << 0);
    colour_buf |= (_cur_palette.palette[val].g << 8);
    colour_buf |= (_cur_palette.palette[val].r << 16);
 
    *ubuf = colour_buf;
    ubuf++;   // Skip alpha
  }
}
 
bool MakeMinimapWorldScreenshot()
{
  return _cur_screenshot_format->proc(MakeScreenshotName(SCREENSHOT_NAME, _cur_screenshot_format->extension), MinimapScreenCallback, nullptr, Map::SizeX(), Map::SizeY(), 32, _cur_palette.palette);
}