[Graphics] Screenshots: Measure the time for each format/effort setting

Using `std::chrono::steady_clock` rather than insisting on the SDL
functions is *definitely* fine for now:
• On Windows, MSVC implements it in terms of QueryPerformanceCounter(),
  so it will work on 9x as well.
• Also, that one `std::this_thread::sleep_for()` in the MIDI frontend
  has already been using it.

Closes #54.

Completes P0309, funded by Ember2528.

Author: nmlgc

GIAN07/WindowCtrl.cpp

@@ -20,6 +20,8 @@
 #include "game/snd.h"
 #include "game/string_format.h"
 
+using namespace std::chrono_literals;
+
 
 
 static bool ExitFnYes(INPUT_BITS key);
@@ -141,10 +143,20 @@ static void FnFormat(int_fast8_t delta);
 static void SetItem(bool tick = true);
 
 static char TitleFormat[50];
-WINDOW_CHOICE Item[] = {
-	{ TitleFormat, "", FnFormat },
-	SubmenuExitItemForArray,
-};
+static char TitlePerf[GRP_SCREENSHOT_EFFORT_COUNT][50];
+static char HelpPerf[50];
+constinit auto Item = ([] {
+	std::array<WINDOW_CHOICE, (2 + GRP_SCREENSHOT_EFFORT_COUNT + 2)> ret{};
+	auto item_p = ret.begin();
+	*(item_p++) = { TitleFormat, "", FnFormat };
+	*(item_p++) = { "--- Performance ---" };
+	for(const auto& title : Screenshot::TitlePerf) {
+		*(item_p++) = WINDOW_CHOICE{ title, HelpPerf, FnFormat };
+	}
+	*(item_p++) = HRuleItemForArray;
+	*(item_p++) = SubmenuExitItemForArray;
+	return ret;
+})();
 WINDOW_MENU Menu = { std::span(Item), SetItem };
 static auto& ItemFormat = Item[0];
 } // namespace Screenshot
@@ -1076,22 +1088,87 @@ static void Main::Cfg::Grp::Screenshot::SetItem(bool)
 	const auto effort = ConfigDat.ScreenshotEffort.v;
 #endif
 	char format_buf[8];
-	auto format_for = [&format_buf](decltype(effort) effort) -> const char * {
+	enum class ALIGN { LEFT, CENTER };
+	const auto format_for = [&format_buf](
+		decltype(effort) effort, ALIGN align
+	) -> const char * {
 		if(effort == 0) {
-			return "  BMP  ";
+			switch(align) {
+				case ALIGN::LEFT:   return "BMP    ";
+				case ALIGN::CENTER: return "  BMP  ";
+			}
 		}
 		strcpy(format_buf, "WebP z");
 		format_buf[6] = ('0' + (effort - 1));
 		format_buf[7] = '\0';
 		return &format_buf[0];
 	};
 
-	sprintf(TitleFormat, "Format    [%s]", format_for(effort));
+	const auto split_into_fraction = [](auto v) {
+		const auto ret_int = (v / 1000);
+		const auto ret_frac = ((v % 1000) / 10);
+		return std::pair(ret_int, ret_frac);
+	};
+
+	sprintf(TitleFormat, "Format    [%s]", format_for(effort, ALIGN::CENTER));
 	if(effort == 0) {
 		ItemFormat.Help = "Saving as uncompressed .BMP";
 	} else {
 		ItemFormat.Help = ("Lossless compression (higher = slower)");
 	}
+
+	for(const auto i : std::views::iota(0u, GRP_SCREENSHOT_EFFORT_COUNT)) {
+		auto& item = Item[2 + i];
+		const auto hovered = (
+			MainWindow.Select[MainWindow.SelectDepth] == (2 + i)
+		);
+		const auto format = format_for(i, ALIGN::LEFT);
+		const auto time = Grp_ScreenshotTimes[i];
+		EnumFlagSet(item.Flags, WINDOW_FLAGS::HIGHLIGHT, (i == effort));
+		if(time < 0s) {
+			sprintf(TitlePerf[i], "%s[  FAILED  ]", format);
+			if(hovered) {
+				strcpy(HelpPerf, "https://github.com/nmlgc/ssg/issues/23");
+			}
+		} else if(time == 0s) {
+			sprintf(TitlePerf[i], "%s[    ？    ]", format);
+			if(hovered) {
+				strcpy(HelpPerf, "Not yet measured");
+			}
+		} else {
+			const auto [time_int, time_frac] = split_into_fraction(
+				std::chrono::duration_cast<decltype(0us)>(time).count() + 5
+			);
+			sprintf(
+				TitlePerf[i], "%s[%5lld.%02lldms]", format, time_int, time_frac
+			);
+			if(hovered) {
+				constexpr auto target_ms = decltype(0ms)(FRAME_TIME_TARGET);
+				if(time > (target_ms * ConfigDat.FPSDivisor.v)) {
+					const auto fps = split_into_fraction((1000s / time));
+					sprintf(
+						HelpPerf,
+						"Frame rate will drop to ～%lld.%02lld FPS",
+						fps.first,
+						fps.second
+					);
+				} else {
+					// Easier to just hardcode the numbers than to calculate
+					// and format this without using floating-point variables...
+					static constexpr const char *FPS[3] = {
+						"62.5", "30", "20"
+					};
+					assert(ConfigDat.FPSDivisor.v > 0);
+					assert((ConfigDat.FPSDivisor.v - 1) < std::size(FPS));
+					sprintf(
+						HelpPerf,
+						"Frame rate will stay at %s FPS",
+						FPS[ConfigDat.FPSDivisor.v - 1]
+					);
+				}
+			}
+		}
+	}
 }
 
 #ifdef SUPPORT_GRP_API

game/graphics.cpp

@@ -13,6 +13,9 @@
 #include <webp/encode.h>
 
 uint8_t Grp_FPSDivisor = 0;
+std::chrono::steady_clock::duration Grp_ScreenshotTimes[
+	GRP_SCREENSHOT_EFFORT_COUNT
+];
 
 // Paletted graphics //
 // ----------------- //
@@ -212,17 +215,26 @@ bool Grp_ScreenshotSave(
 	PIXEL_SIZE_BASE<unsigned int> size,
 	PIXELFORMAT format,
 	std::span<BGRA> palette,
-	std::span<const std::byte> pixels
+	std::span<const std::byte> pixels,
+	const std::chrono::steady_clock::time_point t_start
 )
 {
+	constexpr auto DURATION_FAILED = std::chrono::steady_clock::duration(-1);
+
 	auto ret = false;
-	const auto effort = Grp_ScreenshotEffort;
+	auto effort = Grp_ScreenshotEffort;
 	if(effort != 0) {
 		ret = ScreenshotSaveWebP(size, format, palette, pixels, (effort - 1));
+		if(!ret) {
+			Grp_ScreenshotTimes[effort] = DURATION_FAILED;
+		}
 	}
 	if(!ret) {
+		effort = 0;
 		ret = ScreenshotSaveBMP(size, format, palette, pixels);
 	}
+	const auto t_end = std::chrono::steady_clock::now();
+	Grp_ScreenshotTimes[effort] = (ret ? (t_end - t_start) : DURATION_FAILED);
 	return ret;
 }
 // -----------

game/graphics.h

@@ -119,16 +119,23 @@ constexpr uint8_t GRP_SCREENSHOT_EFFORT_MAX = (GRP_SCREENSHOT_EFFORT_COUNT - 1);
 
 extern const uint8_t& Grp_ScreenshotEffort;
 
+// 0 = not yet tried, -1 = last attempt failed.
+extern std::chrono::steady_clock::duration Grp_ScreenshotTimes[
+	GRP_SCREENSHOT_EFFORT_COUNT
+];
+
 // Required to enable the screenshot feature as a whole.
 void Grp_ScreenshotSetPrefix(std::u8string_view prefix);
 
 // Saves the given bitmap in the screenshot format to a file with the
-// screenshot prefix.
+// screenshot prefix. [t_start] represents the very beginning of the backend's
+// capturing process.
 bool Grp_ScreenshotSave(
 	PIXEL_SIZE_BASE<unsigned int> size,
 	PIXELFORMAT format,
 	std::span<BGRA> palette,
-	std::span<const std::byte> pixels
+	std::span<const std::byte> pixels,
+	const std::chrono::steady_clock::time_point t_start
 );
 // -----------
 

platform/sdl/graphics_sdl.cpp

@@ -986,7 +986,9 @@ PIXELFORMAT GrpBackend_PixelFormat(void)
 void GrpBackend_PaletteGet(PALETTE& pal) {}
 bool GrpBackend_PaletteSet(const PALETTE& pal) { return false; }
 
-void SaveSurfaceAsScreenshot(SDL_Surface *src)
+void SaveSurfaceAsScreenshot(
+	SDL_Surface *src, const std::chrono::steady_clock::time_point t_start
+)
 {
 	assert(src);
 	assert(src->pitch >= 0);
@@ -1020,18 +1022,22 @@ void SaveSurfaceAsScreenshot(SDL_Surface *src)
 	const auto pixels = std::span(
 		static_cast<std::byte *>(src->pixels), (src->h * src->pitch)
 	);
-	Grp_ScreenshotSave(size, maybe_format.value(), {}, pixels);
+	Grp_ScreenshotSave(size, maybe_format.value(), {}, pixels, t_start);
 	if(SDL_MUSTLOCK(src)) {
 		SDL_UnlockSurface(src);
 	}
 }
 
 void TakeScreenshot(void)
 {
+	// The rendering itself should not impact screenshot timing.
+	SDL_FlushRenderer(Renderer);
+	const auto t_start = std::chrono::steady_clock::now();
+
 	if(SoftwareRenderer) {
 		// Software rendering is the ideal case for screenshots, because we
 		// already have a system-memory surface we can save.
-		SaveSurfaceAsScreenshot(SoftwareSurface);
+		SaveSurfaceAsScreenshot(SoftwareSurface, t_start);
 		return;
 	}
 
@@ -1092,7 +1098,7 @@ void TakeScreenshot(void)
 		SDL_UnlockSurface(src);
 	}
 #endif
-	SaveSurfaceAsScreenshot(src);
+	SaveSurfaceAsScreenshot(src, t_start);
 }
 
 void GrpBackend_Flip(bool take_screenshot)

platform/windows_vintage/DD_UTY.CPP

@@ -194,6 +194,7 @@ bool DDrawSaveScreenshot(IDirectDrawSurface *surf)
 	if(!surf) {
 		return false;
 	}
+	const auto t_start = std::chrono::steady_clock::now();
 	std::array<BGRA, BMP_PALETTE_SIZE_MAX> bgra_memory;
 	const auto palette = [surf, &bgra_memory]() -> std::span<BGRA> {
 		IDirectDrawPalette* pal = nullptr;
@@ -257,7 +258,7 @@ bool DDrawSaveScreenshot(IDirectDrawSurface *surf)
 		format = { PIXELFORMAT::BGRX8888 };
 	}
 
-	return Grp_ScreenshotSave(size, format, palette, pixels);
+	return Grp_ScreenshotSave(size, format, palette, pixels, t_start);
 }