Skip to content

Commit

Permalink
System: Add save state compression mode options
Browse files Browse the repository at this point in the history
  • Loading branch information
@stenzek
stenzek committed Aug 6, 2024
1 parent 7041178 commit aeb9d38
Show file tree
Hide file tree
Showing 7 changed files with 124 additions and 48 deletions.
9 changes: 8 additions & 1 deletion src/core/fullscreen_ui.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5184,9 +5184,14 @@ void FullscreenUI::DrawAdvancedSettingsPage()
FSUI_CSTR("Renames existing save states when saving to a backup file."), "Main",
"CreateSaveStateBackups", false);
DrawToggleSetting(
bsi, FSUI_ICONSTR(ICON_FA_GAMEPAD, "Load Devices From Save States"),
bsi, FSUI_CSTR("Load Devices From Save States"),
FSUI_CSTR("When enabled, memory cards and controllers will be overwritten when save states are loaded."), "Main",
"LoadDevicesFromSaveStates", false);
DrawEnumSetting(bsi, FSUI_CSTR("Save State Compression"),
FSUI_CSTR("Reduces the size of save states by compressing the data before saving."), "Main",
"SaveStateCompression", Settings::DEFAULT_SAVE_STATE_COMPRESSION_MODE,
&Settings::ParseSaveStateCompressionModeName, &Settings::GetSaveStateCompressionModeName,
&Settings::GetSaveStateCompressionModeDisplayName, SaveStateCompressionMode::Count);

MenuHeading(FSUI_CSTR("Display Settings"));
DrawToggleSetting(bsi, FSUI_CSTR("Show Status Indicators"),
Expand Down Expand Up @@ -7618,6 +7623,7 @@ TRANSLATE_NOOP("FullscreenUI", "Reduces \"wobbly\" polygons by attempting to pre
TRANSLATE_NOOP("FullscreenUI", "Reduces hitches in emulation by reading/decompressing CD data asynchronously on a worker thread.");
TRANSLATE_NOOP("FullscreenUI", "Reduces input latency by delaying the start of frame until closer to the presentation time.");
TRANSLATE_NOOP("FullscreenUI", "Reduces polygon Z-fighting through depth testing. Low compatibility with games.");
TRANSLATE_NOOP("FullscreenUI", "Reduces the size of save states by compressing the data before saving.");
TRANSLATE_NOOP("FullscreenUI", "Region");
TRANSLATE_NOOP("FullscreenUI", "Region: ");
TRANSLATE_NOOP("FullscreenUI", "Release Date: %s");
Expand Down Expand Up @@ -7661,6 +7667,7 @@ TRANSLATE_NOOP("FullscreenUI", "SDL DualShock 4 / DualSense Enhanced Mode");
TRANSLATE_NOOP("FullscreenUI", "Save Profile");
TRANSLATE_NOOP("FullscreenUI", "Save Screenshot");
TRANSLATE_NOOP("FullscreenUI", "Save State");
TRANSLATE_NOOP("FullscreenUI", "Save State Compression");
TRANSLATE_NOOP("FullscreenUI", "Save State On Exit");
TRANSLATE_NOOP("FullscreenUI", "Saved {:%c}");
TRANSLATE_NOOP("FullscreenUI", "Saves state periodically so you can rewind any mistakes while playing.");
Expand Down
14 changes: 7 additions & 7 deletions src/core/save_state_version.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,13 +11,6 @@ static constexpr u32 SAVE_STATE_MINIMUM_VERSION = 42;

static_assert(SAVE_STATE_VERSION >= SAVE_STATE_MINIMUM_VERSION);

enum class SaveStateCompression : u32
{
None = 0,
ZLib = 1,
ZStd = 2,
};

#pragma pack(push, 4)
struct SAVE_STATE_HEADER
{
Expand All @@ -28,6 +21,13 @@ struct SAVE_STATE_HEADER
MAX_SAVE_STATE_SIZE = 32 * 1024 * 1024,
};

enum class CompressionType : u32
{
None = 0,
Deflate = 1,
Zstandard = 2,
};

u32 magic;
u32 version;
char title[MAX_TITLE_LENGTH];
Expand Down
46 changes: 44 additions & 2 deletions src/core/settings.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -147,7 +147,6 @@ void Settings::Load(SettingsInterface& si)
pause_on_controller_disconnection = si.GetBoolValue("Main", "PauseOnControllerDisconnection", false);
save_state_on_exit = si.GetBoolValue("Main", "SaveStateOnExit", true);
create_save_state_backups = si.GetBoolValue("Main", "CreateSaveStateBackups", DEFAULT_SAVE_STATE_BACKUPS);
compress_save_states = si.GetBoolValue("Main", "CompressSaveStates", DEFAULT_SAVE_STATE_COMPRESSION);
confim_power_off = si.GetBoolValue("Main", "ConfirmPowerOff", true);
load_devices_from_save_states = si.GetBoolValue("Main", "LoadDevicesFromSaveStates", false);
apply_compatibility_settings = si.GetBoolValue("Main", "ApplyCompatibilitySettings", true);
Expand Down Expand Up @@ -311,6 +310,12 @@ void Settings::Load(SettingsInterface& si)
display_stretch_vertically = si.GetBoolValue("Display", "StretchVertically", false);
display_osd_scale = si.GetFloatValue("Display", "OSDScale", DEFAULT_OSD_SCALE);

save_state_compression = ParseSaveStateCompressionModeName(
si.GetStringValue("Main", "SaveStateCompression",
GetSaveStateCompressionModeName(DEFAULT_SAVE_STATE_COMPRESSION_MODE))
.c_str())
.value_or(DEFAULT_SAVE_STATE_COMPRESSION_MODE);

cdrom_readahead_sectors =
static_cast<u8>(si.GetIntValue("CDROM", "ReadaheadSectors", DEFAULT_CDROM_READAHEAD_SECTORS));
cdrom_mechacon_version =
Expand Down Expand Up @@ -462,7 +467,7 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
si.SetBoolValue("Main", "PauseOnControllerDisconnection", pause_on_controller_disconnection);
si.SetBoolValue("Main", "SaveStateOnExit", save_state_on_exit);
si.SetBoolValue("Main", "CreateSaveStateBackups", create_save_state_backups);
si.SetBoolValue("Main", "CompressSaveStates", compress_save_states);
si.SetStringValue("Main", "SaveStateCompression", GetSaveStateCompressionModeName(save_state_compression));
si.SetBoolValue("Main", "ConfirmPowerOff", confim_power_off);
si.SetBoolValue("Main", "EnableDiscordPresence", enable_discord_presence);
}
Expand Down Expand Up @@ -1764,6 +1769,43 @@ const char* Settings::GetCDROMMechVersionDisplayName(CDROMMechaconVersion mode)
return s_mechacon_version_display_names[static_cast<size_t>(mode)];
}

static constexpr const std::array s_save_state_compression_mode_names = {
"Uncompressed", "DeflateLow", "DeflateDefault", "DeflateHigh", "ZstLow", "ZstDefault", "ZstHigh",
};
static constexpr const std::array s_save_state_compression_mode_display_names = {
TRANSLATE_NOOP("Settings", "Uncompressed"), TRANSLATE_NOOP("Settings", "Deflate (Low)"),
TRANSLATE_NOOP("Settings", "Deflate (Default)"), TRANSLATE_NOOP("Settings", "Deflate (High)"),
TRANSLATE_NOOP("Settings", "Zstandard (Low)"), TRANSLATE_NOOP("Settings", "Zstandard (Default)"),
TRANSLATE_NOOP("Settings", "Zstandard (High)"),
};
static_assert(s_save_state_compression_mode_names.size() == static_cast<size_t>(SaveStateCompressionMode::Count));
static_assert(s_save_state_compression_mode_display_names.size() ==
static_cast<size_t>(SaveStateCompressionMode::Count));

std::optional<SaveStateCompressionMode> Settings::ParseSaveStateCompressionModeName(const char* str)
{
u32 index = 0;
for (const char* name : s_save_state_compression_mode_names)
{
if (StringUtil::Strcasecmp(name, str) == 0)
return static_cast<SaveStateCompressionMode>(index);

index++;
}

return std::nullopt;
}

const char* Settings::GetSaveStateCompressionModeName(SaveStateCompressionMode mode)
{
return s_save_state_compression_mode_names[static_cast<size_t>(mode)];
}

const char* Settings::GetSaveStateCompressionModeDisplayName(SaveStateCompressionMode mode)
{
return Host::TranslateToCString("Settings", s_save_state_compression_mode_display_names[static_cast<size_t>(mode)]);
}

std::string EmuFolders::AppRoot;
std::string EmuFolders::DataRoot;
std::string EmuFolders::Bios;
Expand Down
15 changes: 10 additions & 5 deletions src/core/settings.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -63,14 +63,14 @@ struct Settings
ConsoleRegion region = DEFAULT_CONSOLE_REGION;

CPUExecutionMode cpu_execution_mode = DEFAULT_CPU_EXECUTION_MODE;
u32 cpu_overclock_numerator = 1;
u32 cpu_overclock_denominator = 1;
CPUFastmemMode cpu_fastmem_mode = DEFAULT_CPU_FASTMEM_MODE;
bool cpu_overclock_enable : 1 = false;
bool cpu_overclock_active : 1 = false;
bool cpu_recompiler_memory_exceptions : 1 = false;
bool cpu_recompiler_block_linking : 1 = true;
bool cpu_recompiler_icache : 1 = false;
CPUFastmemMode cpu_fastmem_mode = DEFAULT_CPU_FASTMEM_MODE;
u32 cpu_overclock_numerator = 1;
u32 cpu_overclock_denominator = 1;

float emulation_speed = 1.0f;
float fast_forward_speed = 0.0f;
Expand All @@ -84,7 +84,6 @@ struct Settings
bool pause_on_controller_disconnection : 1 = false;
bool save_state_on_exit : 1 = true;
bool create_save_state_backups : 1 = DEFAULT_SAVE_STATE_BACKUPS;
bool compress_save_states : 1 = DEFAULT_SAVE_STATE_COMPRESSION;
bool confim_power_off : 1 = true;
bool load_devices_from_save_states : 1 = false;
bool apply_compatibility_settings : 1 = true;
Expand Down Expand Up @@ -180,6 +179,8 @@ struct Settings
float gpu_pgxp_tolerance = -1.0f;
float gpu_pgxp_depth_clear_threshold = DEFAULT_GPU_PGXP_DEPTH_THRESHOLD / GPU_PGXP_DEPTH_THRESHOLD_SCALE;

SaveStateCompressionMode save_state_compression = DEFAULT_SAVE_STATE_COMPRESSION_MODE;

u8 cdrom_readahead_sectors = DEFAULT_CDROM_READAHEAD_SECTORS;
CDROMMechaconVersion cdrom_mechacon_version = DEFAULT_CDROM_MECHACON_VERSION;
bool cdrom_region_check : 1 = false;
Expand Down Expand Up @@ -459,6 +460,10 @@ struct Settings
static const char* GetCDROMMechVersionName(CDROMMechaconVersion mode);
static const char* GetCDROMMechVersionDisplayName(CDROMMechaconVersion mode);

static std::optional<SaveStateCompressionMode> ParseSaveStateCompressionModeName(const char* str);
static const char* GetSaveStateCompressionModeName(SaveStateCompressionMode mode);
static const char* GetSaveStateCompressionModeDisplayName(SaveStateCompressionMode mode);

static constexpr GPURenderer DEFAULT_GPU_RENDERER = GPURenderer::Automatic;
static constexpr GPUTextureFilter DEFAULT_GPU_TEXTURE_FILTER = GPUTextureFilter::Nearest;
static constexpr GPULineDetectMode DEFAULT_GPU_LINE_DETECT_MODE = GPULineDetectMode::Disabled;
Expand Down Expand Up @@ -510,7 +515,7 @@ struct Settings

static constexpr LOGLEVEL DEFAULT_LOG_LEVEL = LOGLEVEL_INFO;

static constexpr bool DEFAULT_SAVE_STATE_COMPRESSION = true;
static constexpr SaveStateCompressionMode DEFAULT_SAVE_STATE_COMPRESSION_MODE = SaveStateCompressionMode::ZstDefault;

// Enable console logging by default on Linux platforms.
#if defined(__linux__) && !defined(__ANDROID__)
Expand Down
63 changes: 34 additions & 29 deletions src/core/system.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -190,12 +190,12 @@ static bool LoadStateFromBuffer(const SaveStateBuffer& buffer, Error* error, boo
static bool LoadStateBufferFromFile(SaveStateBuffer* buffer, std::FILE* fp, Error* error, bool read_title,
bool read_media_path, bool read_screenshot, bool read_data);
static bool ReadAndDecompressStateData(std::FILE* fp, std::span<u8> dst, u32 file_offset, u32 compressed_size,
SaveStateCompression method, Error* error);
SAVE_STATE_HEADER::CompressionType method, Error* error);
static bool SaveStateToBuffer(SaveStateBuffer* buffer, Error* error, u32 screenshot_size = 256);
static bool SaveStateBufferToFile(const SaveStateBuffer& buffer, std::FILE* fp, Error* error,
SaveStateCompression screenshot_compression = SaveStateCompression::ZLib,
SaveStateCompression data_compression = SaveStateCompression::ZStd);
static u32 CompressAndWriteStateData(std::FILE* fp, std::span<const u8> src, SaveStateCompression method, Error* error);
SaveStateCompressionMode compression_mode);
static u32 CompressAndWriteStateData(std::FILE* fp, std::span<const u8> src, SaveStateCompressionMode method,
u32* header_type, Error* error);
static bool DoState(StateWrapper& sw, GPUTexture** host_texture, bool update_display, bool is_memory_state);

static void SetRewinding(bool enabled);
Expand Down Expand Up @@ -2699,9 +2699,9 @@ bool System::LoadStateBufferFromFile(SaveStateBuffer* buffer, std::FILE* fp, Err
buffer->screenshot.SetSize(header.screenshot_width, header.screenshot_height);
const u32 uncompressed_size = buffer->screenshot.GetPitch() * buffer->screenshot.GetHeight();
const u32 compressed_size = (header.version >= 69) ? header.screenshot_compressed_size : uncompressed_size;
const SaveStateCompression compression_type =
(header.version >= 69) ? static_cast<SaveStateCompression>(header.screenshot_compression_type) :
SaveStateCompression::None;
const SAVE_STATE_HEADER::CompressionType compression_type =
(header.version >= 69) ? static_cast<SAVE_STATE_HEADER::CompressionType>(header.screenshot_compression_type) :
SAVE_STATE_HEADER::CompressionType::None;
if (!ReadAndDecompressStateData(
fp, std::span<u8>(reinterpret_cast<u8*>(buffer->screenshot.GetPixels()), uncompressed_size),
header.offset_to_screenshot, compressed_size, compression_type, error)) [[unlikely]]
Expand All @@ -2716,8 +2716,8 @@ bool System::LoadStateBufferFromFile(SaveStateBuffer* buffer, std::FILE* fp, Err
buffer->state_data.resize(header.data_uncompressed_size);
buffer->state_size = header.data_uncompressed_size;
if (!ReadAndDecompressStateData(fp, buffer->state_data.span(), header.offset_to_data, header.data_compressed_size,
static_cast<SaveStateCompression>(header.data_compression_type), error))
[[unlikely]]
static_cast<SAVE_STATE_HEADER::CompressionType>(header.data_compression_type),
error)) [[unlikely]]
{
return false;
}
Expand All @@ -2727,12 +2727,12 @@ bool System::LoadStateBufferFromFile(SaveStateBuffer* buffer, std::FILE* fp, Err
}

bool System::ReadAndDecompressStateData(std::FILE* fp, std::span<u8> dst, u32 file_offset, u32 compressed_size,
SaveStateCompression method, Error* error)
SAVE_STATE_HEADER::CompressionType method, Error* error)
{
if (!FileSystem::FSeek64(fp, file_offset, SEEK_SET, error))
return false;

if (method == SaveStateCompression::None)
if (method == SAVE_STATE_HEADER::CompressionType::None)
{
// Feed through.
if (std::fread(dst.data(), dst.size(), 1, fp) != 1) [[unlikely]]
Expand All @@ -2751,7 +2751,7 @@ bool System::ReadAndDecompressStateData(std::FILE* fp, std::span<u8> dst, u32 fi
return false;
}

if (method == SaveStateCompression::ZLib)
if (method == SAVE_STATE_HEADER::CompressionType::Deflate)
{
uLong source_len = compressed_size;
uLong dest_len = static_cast<uLong>(dst.size());
Expand All @@ -2772,7 +2772,7 @@ bool System::ReadAndDecompressStateData(std::FILE* fp, std::span<u8> dst, u32 fi

return true;
}
else if (method == SaveStateCompression::ZStd)
else if (method == SAVE_STATE_HEADER::CompressionType::Zstandard)
{
const size_t result = ZSTD_decompress(dst.data(), dst.size(), compressed_data.data(), compressed_size);
if (ZSTD_isError(result)) [[unlikely]]
Expand Down Expand Up @@ -2832,9 +2832,7 @@ bool System::SaveState(const char* path, Error* error, bool backup_existing_save

INFO_LOG("Saving state to '{}'...", path);

const SaveStateCompression compression =
g_settings.compress_save_states ? SaveStateCompression::ZStd : SaveStateCompression::None;
if (!SaveStateBufferToFile(buffer, fp.get(), error, compression, compression))
if (!SaveStateBufferToFile(buffer, fp.get(), error, g_settings.save_state_compression))
{
FileSystem::DiscardAtomicRenamedFile(fp);
return false;
Expand Down Expand Up @@ -2927,7 +2925,7 @@ bool System::SaveStateToBuffer(SaveStateBuffer* buffer, Error* error, u32 screen
}

bool System::SaveStateBufferToFile(const SaveStateBuffer& buffer, std::FILE* fp, Error* error,
SaveStateCompression screenshot_compression, SaveStateCompression data_compression)
SaveStateCompressionMode compression)
{
// Header gets rewritten below.
SAVE_STATE_HEADER header = {};
Expand Down Expand Up @@ -2961,26 +2959,24 @@ bool System::SaveStateBufferToFile(const SaveStateBuffer& buffer, std::FILE* fp,
if (buffer.screenshot.IsValid())
{
DebugAssert(FileSystem::FTell64(fp) == static_cast<s64>(file_position));
header.screenshot_compression_type = static_cast<u32>(screenshot_compression);
header.screenshot_width = buffer.screenshot.GetWidth();
header.screenshot_height = buffer.screenshot.GetHeight();
header.offset_to_screenshot = file_position;
header.screenshot_compressed_size =
CompressAndWriteStateData(fp,
std::span<const u8>(reinterpret_cast<const u8*>(buffer.screenshot.GetPixels()),
buffer.screenshot.GetPitch() * buffer.screenshot.GetHeight()),
screenshot_compression, error);
compression, &header.screenshot_compression_type, error);
if (header.screenshot_compressed_size == 0)
return false;
file_position += header.screenshot_compressed_size;
}

DebugAssert(buffer.state_size > 0);
header.offset_to_data = file_position;
header.data_compression_type = static_cast<u32>(data_compression);
header.data_uncompressed_size = static_cast<u32>(buffer.state_size);
header.data_compressed_size =
CompressAndWriteStateData(fp, buffer.state_data.cspan(0, buffer.state_size), data_compression, error);
header.data_compressed_size = CompressAndWriteStateData(fp, buffer.state_data.cspan(0, buffer.state_size),
compression, &header.data_compression_type, error);
if (header.data_compressed_size == 0)
return false;

Expand All @@ -3001,50 +2997,59 @@ bool System::SaveStateBufferToFile(const SaveStateBuffer& buffer, std::FILE* fp,
return true;
}

u32 System::CompressAndWriteStateData(std::FILE* fp, std::span<const u8> src, SaveStateCompression method, Error* error)
u32 System::CompressAndWriteStateData(std::FILE* fp, std::span<const u8> src, SaveStateCompressionMode method,
u32* header_type, Error* error)
{
if (method == SaveStateCompression::None)
if (method == SaveStateCompressionMode::Uncompressed)
{
if (std::fwrite(src.data(), src.size(), 1, fp) != 1) [[unlikely]]
{
Error::SetStringFmt(error, "fwrite() failed: {}", errno);
return 0;
}

*header_type = static_cast<u32>(SAVE_STATE_HEADER::CompressionType::None);
return static_cast<u32>(src.size());
}

DynamicHeapArray<u8> buffer;
u32 write_size;
if (method == SaveStateCompression::ZLib)
if (method >= SaveStateCompressionMode::DeflateLow && method <= SaveStateCompressionMode::DeflateHigh)
{
const size_t buffer_size = compressBound(static_cast<uLong>(src.size()));
buffer.resize(buffer_size);

uLongf compressed_size = static_cast<uLongf>(buffer_size);
const int err =
compress2(buffer.data(), &compressed_size, src.data(), static_cast<uLong>(src.size()), Z_DEFAULT_COMPRESSION);
const int level =
((method == SaveStateCompressionMode::DeflateLow) ?
Z_BEST_SPEED :
((method == SaveStateCompressionMode::DeflateHigh) ? Z_BEST_COMPRESSION : Z_DEFAULT_COMPRESSION));
const int err = compress2(buffer.data(), &compressed_size, src.data(), static_cast<uLong>(src.size()), level);
if (err != Z_OK) [[unlikely]]
{
Error::SetStringFmt(error, "compress2() failed: {}", err);
return 0;
}

*header_type = static_cast<u32>(SAVE_STATE_HEADER::CompressionType::Deflate);
write_size = static_cast<u32>(compressed_size);
}
else if (method == SaveStateCompression::ZStd)
else if (method >= SaveStateCompressionMode::ZstLow && method <= SaveStateCompressionMode::ZstHigh)
{
const size_t buffer_size = ZSTD_compressBound(src.size());
buffer.resize(buffer_size);

const size_t compressed_size = ZSTD_compress(buffer.data(), buffer_size, src.data(), src.size(), 0);
const int level =
((method == SaveStateCompressionMode::ZstLow) ? 1 : ((method == SaveStateCompressionMode::ZstHigh) ? 19 : 0));
const size_t compressed_size = ZSTD_compress(buffer.data(), buffer_size, src.data(), src.size(), level);
if (ZSTD_isError(compressed_size)) [[unlikely]]
{
const char* errstr = ZSTD_getErrorString(ZSTD_getErrorCode(compressed_size));
Error::SetStringFmt(error, "ZSTD_compress() failed: {}", errstr ? errstr : "<unknown>");
return 0;
}

*header_type = static_cast<u32>(SAVE_STATE_HEADER::CompressionType::Zstandard);
write_size = static_cast<u32>(compressed_size);
}
else [[unlikely]]
Expand Down
Loading

0 comments on commit aeb9d38

Please sign in to comment.