#include "gb.h" #include #include #include #ifdef GB_BIG_ENDIAN #define BESS_NAME "SameBoy v" GB_VERSION " (Big Endian)" #else #define BESS_NAME "SameBoy v" GB_VERSION #endif _Static_assert((GB_SECTION_OFFSET(core_state) & 7) == 0, "Section core_state is not aligned"); _Static_assert((GB_SECTION_OFFSET(dma) & 7) == 0, "Section dma is not aligned"); _Static_assert((GB_SECTION_OFFSET(mbc) & 7) == 0, "Section mbc is not aligned"); _Static_assert((GB_SECTION_OFFSET(hram) & 7) == 0, "Section hram is not aligned"); _Static_assert((GB_SECTION_OFFSET(timing) & 7) == 0, "Section timing is not aligned"); _Static_assert((GB_SECTION_OFFSET(apu) & 7) == 0, "Section apu is not aligned"); _Static_assert((GB_SECTION_OFFSET(rtc) & 7) == 0, "Section rtc is not aligned"); _Static_assert((GB_SECTION_OFFSET(video) & 7) == 0, "Section video is not aligned"); typedef struct __attribute__((packed)) { uint32_t magic; uint32_t size; } BESS_block_t; typedef struct __attribute__((packed)) { uint32_t size; uint32_t offset; } BESS_buffer_t; typedef struct __attribute__((packed)) { uint32_t start_offset; uint32_t magic; } BESS_footer_t; typedef struct __attribute__((packed)) { BESS_block_t header; uint16_t major; uint16_t minor; union { struct { char family; char model; char revision; char padding; }; uint32_t full_model; }; uint16_t pc; uint16_t af; uint16_t bc; uint16_t de; uint16_t hl; uint16_t sp; uint8_t ime; uint8_t ie; uint8_t execution_mode; // 0 = running; 1 = halted; 2 = stopped uint8_t _padding; uint8_t io_registers[0x80]; BESS_buffer_t ram; BESS_buffer_t vram; BESS_buffer_t mbc_ram; BESS_buffer_t oam; BESS_buffer_t hram; BESS_buffer_t background_palettes; BESS_buffer_t object_palettes; } BESS_CORE_t; typedef struct __attribute__((packed)) { BESS_block_t header; uint8_t extra_oam[96]; } BESS_XOAM_t; typedef struct __attribute__((packed)) { BESS_block_t header; BESS_buffer_t border_tiles; BESS_buffer_t border_tilemap; BESS_buffer_t border_palettes; BESS_buffer_t active_palettes; BESS_buffer_t ram_palettes; BESS_buffer_t attribute_map; BESS_buffer_t attribute_files; uint8_t multiplayer_state; } BESS_SGB_t; typedef struct __attribute__((packed)){ BESS_block_t header; char title[0x10]; uint8_t checksum[2]; } BESS_INFO_t; /* Same RTC format as used by VBA, BGB and SameBoy in battery saves*/ typedef struct __attribute__((packed)){ BESS_block_t header; struct { uint8_t seconds; uint8_t padding1[3]; uint8_t minutes; uint8_t padding2[3]; uint8_t hours; uint8_t padding3[3]; uint8_t days; uint8_t padding4[3]; uint8_t high; uint8_t padding5[3]; } real, latched; uint64_t last_rtc_second; } BESS_RTC_t; /* Same HuC3 RTC format as used by SameBoy and BGB in battery saves */ typedef struct __attribute__((packed)){ BESS_block_t header; GB_huc3_rtc_time_t data; } BESS_HUC3_t; typedef struct __attribute__((packed)){ BESS_block_t header; uint64_t last_rtc_second; uint8_t real_rtc_data[4]; uint8_t latched_rtc_data[4]; uint8_t mr4; } BESS_TPP1_t; typedef struct __attribute__((packed)) { uint16_t address; uint8_t value; } BESS_MBC_pair_t; typedef struct virtual_file_s virtual_file_t; struct virtual_file_s { size_t (*read)(virtual_file_t *file, void *dest, size_t length); size_t (*write)(virtual_file_t *file, const void *dest, size_t length); void (*seek)(virtual_file_t *file, ssize_t ammount, int origin); size_t (*tell)(virtual_file_t *file); union { FILE *file; struct { uint8_t *buffer; size_t position; size_t size; }; }; }; static size_t file_read(virtual_file_t *file, void *dest, size_t length) { return fread(dest, 1, length, file->file); } static void file_seek(virtual_file_t *file, ssize_t ammount, int origin) { fseek(file->file, ammount, origin); } static size_t file_write(virtual_file_t *file, const void *src, size_t length) { return fwrite(src, 1, length, file->file); } static size_t file_tell(virtual_file_t *file) { return ftell(file->file); } static size_t buffer_read(virtual_file_t *file, void *dest, size_t length) { if (length & 0x80000000) { return 0; } errno = 0; if (length > file->size - file->position) { errno = EIO; length = file->size - file->position; } memcpy(dest, file->buffer + file->position, length); file->position += length; return length; } static void buffer_seek(virtual_file_t *file, ssize_t ammount, int origin) { switch (origin) { case SEEK_SET: file->position = ammount; break; case SEEK_CUR: file->position += ammount; break; case SEEK_END: file->position = file->size + ammount; break; default: break; } if (file->position > file->size) { file->position = file->size; } } static size_t buffer_write(virtual_file_t *file, const void *src, size_t size) { memcpy(file->buffer + file->position, src, size); file->position += size; return size; } static size_t buffer_tell(virtual_file_t *file) { return file->position; } static size_t bess_size_for_cartridge(const GB_cartridge_t *cart) { switch (cart->mbc_type) { default: case GB_NO_MBC: return 0; case GB_MBC1: return sizeof(BESS_block_t) + 4 * sizeof(BESS_MBC_pair_t); case GB_MBC2: return sizeof(BESS_block_t) + 2 * sizeof(BESS_MBC_pair_t); case GB_MBC3: return sizeof(BESS_block_t) + 3 * sizeof(BESS_MBC_pair_t) + (cart->has_rtc? sizeof(BESS_RTC_t) : 0); case GB_MBC5: return sizeof(BESS_block_t) + 4 * sizeof(BESS_MBC_pair_t); case GB_MMM01: return sizeof(BESS_block_t) + 8 * sizeof(BESS_MBC_pair_t); case GB_HUC1: return sizeof(BESS_block_t) + 4 * sizeof(BESS_MBC_pair_t); case GB_HUC3: return sizeof(BESS_block_t) + 3 * sizeof(BESS_MBC_pair_t) + sizeof(BESS_HUC3_t); case GB_TPP1: return sizeof(BESS_block_t) + 4 * sizeof(BESS_MBC_pair_t) + sizeof(BESS_TPP1_t); } } size_t GB_get_save_state_size_no_bess(GB_gameboy_t *gb) { return GB_SECTION_SIZE(header) + GB_SECTION_SIZE(core_state) + sizeof(uint32_t) + GB_SECTION_SIZE(dma ) + sizeof(uint32_t) + GB_SECTION_SIZE(mbc ) + sizeof(uint32_t) + GB_SECTION_SIZE(hram ) + sizeof(uint32_t) + GB_SECTION_SIZE(timing ) + sizeof(uint32_t) + GB_SECTION_SIZE(apu ) + sizeof(uint32_t) + GB_SECTION_SIZE(rtc ) + sizeof(uint32_t) + GB_SECTION_SIZE(video ) + sizeof(uint32_t) + (GB_is_hle_sgb(gb)? sizeof(*gb->sgb) + sizeof(uint32_t) : 0) + gb->mbc_ram_size + gb->ram_size + gb->vram_size; } size_t GB_get_save_state_size(GB_gameboy_t *gb) { return GB_get_save_state_size_no_bess(gb) + // BESS + sizeof(BESS_block_t) // NAME + sizeof(BESS_NAME) - 1 + sizeof(BESS_INFO_t) // INFO + sizeof(BESS_CORE_t) + sizeof(BESS_XOAM_t) + (gb->sgb? sizeof(BESS_SGB_t) : 0) + bess_size_for_cartridge(gb->cartridge_type) // MBC & RTC/HUC3/TPP1 block + sizeof(BESS_block_t) // END block + sizeof(BESS_footer_t); } static bool verify_and_update_state_compatibility(GB_gameboy_t *gb, GB_gameboy_t *save, bool *attempt_bess) { *attempt_bess = false; if (gb->version != save->version) { GB_log(gb, "The save state is for a different version of SameBoy.\n"); *attempt_bess = true; return false; } if (GB_is_cgb(gb) != GB_is_cgb(save) || GB_is_hle_sgb(gb) != GB_is_hle_sgb(save)) { GB_log(gb, "The save state is for a different Game Boy model. Try changing the emulated model.\n"); return false; } if (gb->mbc_ram_size < save->mbc_ram_size) { GB_log(gb, "The save state has non-matching MBC RAM size.\n"); return false; } if (gb->vram_size != save->vram_size) { GB_log(gb, "The save state has non-matching VRAM size. Try changing the emulated model.\n"); return false; } if (GB_is_hle_sgb(gb) != GB_is_hle_sgb(save)) { GB_log(gb, "The save state is %sfor a Super Game Boy. Try changing the emulated model.\n", GB_is_hle_sgb(save)? "" : "not "); return false; } if (gb->ram_size != save->ram_size) { GB_log(gb, "The save state has non-matching RAM size. Try changing the emulated model.\n"); return false; } switch (save->model) { case GB_MODEL_DMG_B: return true; case GB_MODEL_SGB_NTSC: return true; case GB_MODEL_SGB_PAL: return true; case GB_MODEL_SGB_NTSC_NO_SFC: return true; case GB_MODEL_SGB_PAL_NO_SFC: return true; case GB_MODEL_MGB: return true; case GB_MODEL_SGB2: return true; case GB_MODEL_SGB2_NO_SFC: return true; case GB_MODEL_CGB_0: return true; case GB_MODEL_CGB_A: return true; case GB_MODEL_CGB_B: return true; case GB_MODEL_CGB_C: return true; case GB_MODEL_CGB_D: return true; case GB_MODEL_CGB_E: return true; case GB_MODEL_AGB_A: return true; } if ((gb->model & GB_MODEL_FAMILY_MASK) == (save->model & GB_MODEL_FAMILY_MASK)) { save->model = gb->model; return true; } GB_log(gb, "This save state is for an unknown Game Boy model\n"); return false; } static void sanitize_state(GB_gameboy_t *gb) { for (unsigned i = 0; i < 32; i++) { GB_palette_changed(gb, false, i * 2); GB_palette_changed(gb, true, i * 2); } gb->bg_fifo.read_end &= 0xF; gb->bg_fifo.write_end &= 0xF; gb->oam_fifo.read_end &= 0xF; gb->oam_fifo.write_end &= 0xF; gb->last_tile_index_address &= 0x1FFF; gb->window_tile_x &= 0x1F; /* These are kind of DOS-ish if too large */ if (abs(gb->display_cycles) > 0x80000) { gb->display_cycles = 0; } if (abs(gb->div_cycles) > 0x8000) { gb->div_cycles = 0; } if (!GB_is_cgb(gb)) { gb->cgb_mode = false; } if (gb->ram_size == 0x8000) { gb->cgb_ram_bank &= 0x7; } else { gb->cgb_ram_bank = 1; } if (gb->vram_size != 0x4000) { gb->cgb_vram_bank = 0; } if (!GB_is_cgb(gb)) { gb->current_tile_attributes = 0; } gb->object_low_line_address &= gb->vram_size & ~1; if (gb->lcd_x > gb->position_in_line) { gb->lcd_x = gb->position_in_line; } if (gb->sgb) { if (gb->sgb->player_count != 1 && gb->sgb->player_count != 2 && gb->sgb->player_count != 4) { gb->sgb->player_count = 1; } gb->sgb->current_player &= gb->sgb->player_count - 1; } GB_update_clock_rate(gb); } static bool dump_section(virtual_file_t *file, const void *src, uint32_t size) { if (file->write(file, &size, sizeof(size)) != sizeof(size)) { return false; } if (file->write(file, src, size) != size) { return false; } return true; } #define DUMP_SECTION(gb, f, section) dump_section(f, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section)) static int save_bess_mbc_block(GB_gameboy_t *gb, virtual_file_t *file) { BESS_block_t mbc_block = {BE32('MBC '), 0}; BESS_MBC_pair_t pairs[8]; switch (gb->cartridge_type->mbc_type) { default: case GB_NO_MBC: return 0; case GB_MBC1: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->mbc_ram_enable? 0xA : 0x0}; pairs[1] = (BESS_MBC_pair_t){LE16(0x2000), gb->mbc1.bank_low}; pairs[2] = (BESS_MBC_pair_t){LE16(0x4000), gb->mbc1.bank_high}; pairs[3] = (BESS_MBC_pair_t){LE16(0x6000), gb->mbc1.mode}; mbc_block.size = 4 * sizeof(pairs[0]); break; case GB_MBC2: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->mbc_ram_enable? 0xA : 0x0}; pairs[1] = (BESS_MBC_pair_t){LE16(0x0100), gb->mbc2.rom_bank}; mbc_block.size = 2 * sizeof(pairs[0]); break; case GB_MBC3: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->mbc_ram_enable? 0xA : 0x0}; pairs[1] = (BESS_MBC_pair_t){LE16(0x2000), gb->mbc3.rom_bank}; pairs[2] = (BESS_MBC_pair_t){LE16(0x4000), gb->mbc3.ram_bank | (gb->mbc3.rtc_mapped? 8 : 0)}; mbc_block.size = 3 * sizeof(pairs[0]); break; case GB_MBC5: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->mbc_ram_enable? 0xA : 0x0}; pairs[1] = (BESS_MBC_pair_t){LE16(0x2000), gb->mbc5.rom_bank_low}; pairs[2] = (BESS_MBC_pair_t){LE16(0x3000), gb->mbc5.rom_bank_high}; pairs[3] = (BESS_MBC_pair_t){LE16(0x4000), gb->mbc5.ram_bank}; mbc_block.size = 4 * sizeof(pairs[0]); break; case GB_MMM01: pairs[0] = (BESS_MBC_pair_t){LE16(0x2000), (gb->mmm01.rom_bank_low & (gb->mmm01.rom_bank_mask << 1)) | (gb->mmm01.rom_bank_mid << 5)}; pairs[1] = (BESS_MBC_pair_t){LE16(0x6000), gb->mmm01.mbc1_mode | (gb->mmm01.rom_bank_mask << 2) | (gb->mmm01.multiplex_mode << 6)}; pairs[2] = (BESS_MBC_pair_t){LE16(0x4000), gb->mmm01.ram_bank_low | (gb->mmm01.ram_bank_high << 2) | (gb->mmm01.rom_bank_high << 4) | (gb->mmm01.mbc1_mode_disable << 6)}; pairs[3] = (BESS_MBC_pair_t){LE16(0x0000), (gb->mbc_ram_enable? 0xA : 0x0) | (gb->mmm01.ram_bank_mask << 4) | (gb->mmm01.locked << 6)}; /* For compatibility with emulators that inaccurately emulate MMM01, and also require two writes per register */ pairs[4] = (BESS_MBC_pair_t){LE16(0x2000), (gb->mmm01.rom_bank_low & ~(gb->mmm01.rom_bank_mask << 1))}; pairs[5] = pairs[1]; pairs[6] = pairs[2]; pairs[7] = pairs[3]; mbc_block.size = 8 * sizeof(pairs[0]); break; case GB_HUC1: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->huc1.ir_mode? 0xE : 0x0}; pairs[1] = (BESS_MBC_pair_t){LE16(0x2000), gb->huc1.bank_low}; pairs[2] = (BESS_MBC_pair_t){LE16(0x4000), gb->huc1.bank_high}; pairs[3] = (BESS_MBC_pair_t){LE16(0x6000), gb->huc1.mode}; mbc_block.size = 4 * sizeof(pairs[0]); case GB_HUC3: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->huc3.mode}; pairs[1] = (BESS_MBC_pair_t){LE16(0x2000), gb->huc3.rom_bank}; pairs[2] = (BESS_MBC_pair_t){LE16(0x4000), gb->huc3.ram_bank}; mbc_block.size = 3 * sizeof(pairs[0]); break; case GB_TPP1: pairs[0] = (BESS_MBC_pair_t){LE16(0x0000), gb->tpp1.rom_bank}; pairs[1] = (BESS_MBC_pair_t){LE16(0x0001), gb->tpp1.rom_bank >> 8}; pairs[2] = (BESS_MBC_pair_t){LE16(0x0002), gb->tpp1.rom_bank}; pairs[3] = (BESS_MBC_pair_t){LE16(0x0003), gb->tpp1.mode}; mbc_block.size = 4 * sizeof(pairs[0]); break; } mbc_block.size = LE32(mbc_block.size); if (file->write(file, &mbc_block, sizeof(mbc_block)) != sizeof(mbc_block)) { return errno; } if (file->write(file, &pairs, LE32(mbc_block.size)) != LE32(mbc_block.size)) { return errno; } return 0; } static const uint8_t *get_header_bank(GB_gameboy_t *gb) { if (gb->cartridge_type->mbc_type == GB_MMM01) { return gb->rom + gb->rom_size - 0x8000; } return gb->rom; } static int save_state_internal(GB_gameboy_t *gb, virtual_file_t *file, bool append_bess) { if (file->write(file, GB_GET_SECTION(gb, header), GB_SECTION_SIZE(header)) != GB_SECTION_SIZE(header)) goto error; if (!DUMP_SECTION(gb, file, core_state)) goto error; if (!DUMP_SECTION(gb, file, dma )) goto error; if (!DUMP_SECTION(gb, file, mbc )) goto error; uint32_t hram_offset = file->tell(file) + 4; if (!DUMP_SECTION(gb, file, hram )) goto error; if (!DUMP_SECTION(gb, file, timing )) goto error; if (!DUMP_SECTION(gb, file, apu )) goto error; if (!DUMP_SECTION(gb, file, rtc )) goto error; uint32_t video_offset = file->tell(file) + 4; if (!DUMP_SECTION(gb, file, video )) goto error; uint32_t sgb_offset = 0; if (GB_is_hle_sgb(gb)) { sgb_offset = file->tell(file) + 4; if (!dump_section(file, gb->sgb, sizeof(*gb->sgb))) goto error; } BESS_CORE_t bess_core = {0,}; bess_core.mbc_ram.offset = LE32(file->tell(file)); bess_core.mbc_ram.size = LE32(gb->mbc_ram_size); if (file->write(file, gb->mbc_ram, gb->mbc_ram_size) != gb->mbc_ram_size) { goto error; } bess_core.ram.offset = LE32(file->tell(file)); bess_core.ram.size = LE32(gb->ram_size); if (file->write(file, gb->ram, gb->ram_size) != gb->ram_size) { goto error; } bess_core.vram.offset = LE32(file->tell(file)); bess_core.vram.size = LE32(gb->vram_size); if (file->write(file, gb->vram, gb->vram_size) != gb->vram_size) { goto error; } if (!append_bess) return 0; BESS_footer_t bess_footer = { .start_offset = LE32(file->tell(file)), .magic = BE32('BESS'), }; /* BESS NAME */ static const BESS_block_t bess_name = {BE32('NAME'), LE32(sizeof(BESS_NAME) - 1)}; if (file->write(file, &bess_name, sizeof(bess_name)) != sizeof(bess_name)) { goto error; } if (file->write(file, BESS_NAME, sizeof(BESS_NAME) - 1) != sizeof(BESS_NAME) - 1) { goto error; } /* BESS INFO */ static const BESS_block_t bess_info = {BE32('INFO'), LE32(sizeof(BESS_INFO_t) - sizeof(BESS_block_t))}; if (file->write(file, &bess_info, sizeof(bess_info)) != sizeof(bess_info)) { goto error; } const uint8_t *bank = get_header_bank(gb); if (file->write(file, bank + 0x134, 0x10) != 0x10) { goto error; } if (file->write(file, bank + 0x14E, 2) != 2) { goto error; } /* BESS CORE */ bess_core.header = (BESS_block_t){BE32('CORE'), LE32(sizeof(bess_core) - sizeof(bess_core.header))}; bess_core.major = LE16(1); bess_core.minor = LE16(1); switch (gb->model) { case GB_MODEL_DMG_B: bess_core.full_model = BE32('GDB '); break; case GB_MODEL_MGB: bess_core.full_model = BE32('GM '); break; case GB_MODEL_SGB_NTSC: case GB_MODEL_SGB_NTSC_NO_SFC: bess_core.full_model = BE32('SN '); break; case GB_MODEL_SGB_PAL_NO_SFC: case GB_MODEL_SGB_PAL: bess_core.full_model = BE32('SP '); break; case GB_MODEL_SGB2_NO_SFC: case GB_MODEL_SGB2: bess_core.full_model = BE32('S2 '); break; case GB_MODEL_CGB_0: bess_core.full_model = BE32('CC0 '); break; case GB_MODEL_CGB_A: bess_core.full_model = BE32('CCA '); break; case GB_MODEL_CGB_B: bess_core.full_model = BE32('CCB '); break; case GB_MODEL_CGB_C: bess_core.full_model = BE32('CCC '); break; case GB_MODEL_CGB_D: bess_core.full_model = BE32('CCD '); break; case GB_MODEL_CGB_E: bess_core.full_model = BE32('CCE '); break; case GB_MODEL_AGB_A: bess_core.full_model = BE32('CAA '); break; } bess_core.pc = LE16(gb->pc); bess_core.af = LE16(gb->af); bess_core.bc = LE16(gb->bc); bess_core.de = LE16(gb->de); bess_core.hl = LE16(gb->hl); bess_core.sp = LE16(gb->sp); bess_core.ime = gb->ime; bess_core.ie = gb->interrupt_enable; bess_core.execution_mode = 0; if (gb->halted) { bess_core.execution_mode = 1; } else if (gb->stopped) { bess_core.execution_mode = 2; } memcpy(bess_core.io_registers, gb->io_registers, sizeof(gb->io_registers)); bess_core.io_registers[GB_IO_DIV] = gb->div_counter >> 8; bess_core.io_registers[GB_IO_BANK] = gb->boot_rom_finished; bess_core.io_registers[GB_IO_KEY1] |= gb->cgb_double_speed? 0x80 : 0; bess_core.hram.size = LE32(sizeof(gb->hram)); bess_core.hram.offset = LE32(hram_offset + offsetof(GB_gameboy_t, hram) - GB_SECTION_OFFSET(hram)); bess_core.oam.size = LE32(sizeof(gb->oam)); bess_core.oam.offset = LE32(video_offset + offsetof(GB_gameboy_t, oam) - GB_SECTION_OFFSET(video)); if (GB_is_cgb(gb)) { bess_core.background_palettes.size = LE32(sizeof(gb->background_palettes_data)); bess_core.background_palettes.offset = LE32(video_offset + offsetof(GB_gameboy_t, background_palettes_data) - GB_SECTION_OFFSET(video)); bess_core.object_palettes.size = LE32(sizeof(gb->object_palettes_data)); bess_core.object_palettes.offset = LE32(video_offset + offsetof(GB_gameboy_t, object_palettes_data) - GB_SECTION_OFFSET(video)); } if (file->write(file, &bess_core, sizeof(bess_core)) != sizeof(bess_core)) { goto error; } /* BESS XOAM */ BESS_XOAM_t bess_xoam = {0,}; bess_xoam.header = (BESS_block_t){BE32('XOAM'), LE32(sizeof(bess_xoam) - sizeof(bess_xoam.header))}; if (GB_is_cgb(gb)) { memcpy(bess_xoam.extra_oam, gb->extra_oam, sizeof(bess_xoam.extra_oam)); } if (file->write(file, &bess_xoam, sizeof(bess_xoam)) != sizeof(bess_xoam)) { goto error; } save_bess_mbc_block(gb, file); if (gb->cartridge_type->has_rtc) { if (gb->cartridge_type ->mbc_type == GB_TPP1) { BESS_TPP1_t bess_tpp1 = {0,}; bess_tpp1.header = (BESS_block_t){BE32('TPP1'), LE32(sizeof(bess_tpp1) - sizeof(bess_tpp1.header))}; bess_tpp1.last_rtc_second = LE64(gb->last_rtc_second); unrolled for (unsigned i = 4; i--;) { bess_tpp1.real_rtc_data[i] = gb->rtc_real.data[i ^ 3]; bess_tpp1.latched_rtc_data[i] = gb->rtc_latched.data[i ^ 3]; } bess_tpp1.mr4 = gb->tpp1_mr4; if (file->write(file, &bess_tpp1, sizeof(bess_tpp1)) != sizeof(bess_tpp1)) { goto error; } } else if (gb->cartridge_type ->mbc_type != GB_HUC3) { BESS_RTC_t bess_rtc = {0,}; bess_rtc.header = (BESS_block_t){BE32('RTC '), LE32(sizeof(bess_rtc) - sizeof(bess_rtc.header))}; bess_rtc.real.seconds = gb->rtc_real.seconds; bess_rtc.real.minutes = gb->rtc_real.minutes; bess_rtc.real.hours = gb->rtc_real.hours; bess_rtc.real.days = gb->rtc_real.days; bess_rtc.real.high = gb->rtc_real.high; bess_rtc.latched.seconds = gb->rtc_latched.seconds; bess_rtc.latched.minutes = gb->rtc_latched.minutes; bess_rtc.latched.hours = gb->rtc_latched.hours; bess_rtc.latched.days = gb->rtc_latched.days; bess_rtc.latched.high = gb->rtc_latched.high; bess_rtc.last_rtc_second = LE64(gb->last_rtc_second); if (file->write(file, &bess_rtc, sizeof(bess_rtc)) != sizeof(bess_rtc)) { goto error; } } else { BESS_HUC3_t bess_huc3 = {0,}; bess_huc3.header = (BESS_block_t){BE32('HUC3'), LE32(sizeof(bess_huc3) - sizeof(bess_huc3.header))}; bess_huc3.data = (GB_huc3_rtc_time_t) { LE64(gb->last_rtc_second), LE16(gb->huc3.minutes), LE16(gb->huc3.days), LE16(gb->huc3.alarm_minutes), LE16(gb->huc3.alarm_days), gb->huc3.alarm_enabled, }; if (file->write(file, &bess_huc3, sizeof(bess_huc3)) != sizeof(bess_huc3)) { goto error; } } } bool needs_sgb_padding = false; if (gb->sgb) { /* BESS SGB */ if (gb->sgb->disable_commands) { needs_sgb_padding = true; } else { BESS_SGB_t bess_sgb = {{BE32('SGB '), LE32(sizeof(bess_sgb) - sizeof(bess_sgb.header))}, }; bess_sgb.border_tiles = (BESS_buffer_t){LE32(sizeof(gb->sgb->pending_border.tiles)), LE32(sgb_offset + offsetof(GB_sgb_t, pending_border.tiles))}; bess_sgb.border_tilemap = (BESS_buffer_t){LE32(sizeof(gb->sgb->pending_border.map)), LE32(sgb_offset + offsetof(GB_sgb_t, pending_border.map))}; bess_sgb.border_palettes = (BESS_buffer_t){LE32(sizeof(gb->sgb->pending_border.palette)), LE32(sgb_offset + offsetof(GB_sgb_t, pending_border.palette))}; bess_sgb.active_palettes = (BESS_buffer_t){LE32(sizeof(gb->sgb->effective_palettes)), LE32(sgb_offset + offsetof(GB_sgb_t, effective_palettes))}; bess_sgb.ram_palettes = (BESS_buffer_t){LE32(sizeof(gb->sgb->ram_palettes)), LE32(sgb_offset + offsetof(GB_sgb_t, ram_palettes))}; bess_sgb.attribute_map = (BESS_buffer_t){LE32(sizeof(gb->sgb->attribute_map)), LE32(sgb_offset + offsetof(GB_sgb_t, attribute_map))}; bess_sgb.attribute_files = (BESS_buffer_t){LE32(sizeof(gb->sgb->attribute_files)), LE32(sgb_offset + offsetof(GB_sgb_t, attribute_files))}; bess_sgb.multiplayer_state = (gb->sgb->player_count << 4) | gb->sgb->current_player; if (file->write(file, &bess_sgb, sizeof(bess_sgb)) != sizeof(bess_sgb)) { goto error; } } } /* BESS END */ static const BESS_block_t bess_end = {BE32('END '), 0}; if (file->write(file, &bess_end, sizeof(bess_end)) != sizeof(bess_end)) { goto error; } if (needs_sgb_padding) { static const uint8_t sgb_padding[sizeof(BESS_SGB_t)] = {0,}; file->write(file, sgb_padding, sizeof(sgb_padding)); } /* BESS Footer */ if (file->write(file, &bess_footer, sizeof(bess_footer)) != sizeof(bess_footer)) { goto error; } errno = 0; error: return errno; } int GB_save_state(GB_gameboy_t *gb, const char *path) { FILE *f = fopen(path, "wb"); if (!f) { GB_log(gb, "Could not open save state: %s.\n", strerror(errno)); return errno; } virtual_file_t file = { .write = file_write, .seek = file_seek, .tell = file_tell, .file = f, }; int ret = save_state_internal(gb, &file, true); fclose(f); return ret; } void GB_save_state_to_buffer(GB_gameboy_t *gb, uint8_t *buffer) { virtual_file_t file = { .write = buffer_write, .seek = buffer_seek, .tell = buffer_tell, .buffer = (uint8_t *)buffer, .position = 0, }; save_state_internal(gb, &file, true); assert(file.position == GB_get_save_state_size(gb)); } void GB_save_state_to_buffer_no_bess(GB_gameboy_t *gb, uint8_t *buffer) { virtual_file_t file = { .write = buffer_write, .seek = buffer_seek, .tell = buffer_tell, .buffer = (uint8_t *)buffer, .position = 0, }; save_state_internal(gb, &file, false); assert(file.position == GB_get_save_state_size_no_bess(gb)); } static bool read_section(virtual_file_t *file, void *dest, uint32_t size, bool fix_broken_windows_saves) { uint32_t saved_size = 0; if (file->read(file, &saved_size, sizeof(size)) != sizeof(size)) { return false; } if (fix_broken_windows_saves) { if (saved_size < 4) { return false; } saved_size -= 4; file->seek(file, 4, SEEK_CUR); } if (saved_size <= size) { if (file->read(file, dest, saved_size) != saved_size) { return false; } } else { if (file->read(file, dest, size) != size) { return false; } file->seek(file, saved_size - size, SEEK_CUR); } return true; } static void read_bess_buffer(const BESS_buffer_t *buffer, virtual_file_t *file, uint8_t *dest, size_t max_size) { size_t pos = file->tell(file); file->seek(file, LE32(buffer->offset), SEEK_SET); file->read(file, dest, MIN(LE32(buffer->size), max_size)); file->seek(file, pos, SEEK_SET); if (LE32(buffer->size) < max_size) { memset(dest + LE32(buffer->size), 0, max_size - LE32(buffer->size)); } } static int load_bess_save(GB_gameboy_t *gb, virtual_file_t *file, bool is_sameboy) { char emulator_name[65] = {0,}; file->seek(file, -sizeof(BESS_footer_t), SEEK_END); BESS_footer_t footer = {0, }; file->read(file, &footer, sizeof(footer)); if (footer.magic != BE32('BESS')) { // Not a BESS file if (!is_sameboy) { GB_log(gb, "The file is not a save state, or is from an incompatible operating system.\n"); } return -1; } GB_gameboy_t save; GB_init(&save, gb->model); save.cartridge_type = gb->cartridge_type; file->seek(file, LE32(footer.start_offset), SEEK_SET); bool found_core = false; BESS_CORE_t core = {0,}; bool found_sgb = false; BESS_SGB_t sgb = {0,}; while (true) { BESS_block_t block; if (file->read(file, &block, sizeof(block)) != sizeof(block)) goto error; switch (block.magic) { case BE32('CORE'): if (found_core) goto parse_error; found_core = true; if (LE32(block.size) > sizeof(core) - sizeof(block)) { if (file->read(file, &core.header + 1, sizeof(core) - sizeof(block)) != sizeof(core) - sizeof(block)) goto error; file->seek(file, LE32(block.size) - (sizeof(core) - sizeof(block)), SEEK_CUR); } else { if (file->read(file, &core.header + 1, LE32(block.size)) != LE32(block.size)) goto error; } if (core.major != LE16(1)) { GB_log(gb, "This save state uses an incompatible version of the BESS specification"); GB_free(&save); return -1; } switch (core.family) { case 'C': if (!GB_is_cgb(&save)) goto wrong_model; break; case 'S': if (!GB_is_sgb(&save)) goto wrong_model; break; case 'G': if (GB_is_cgb(&save) || GB_is_sgb(&save)) goto wrong_model; break; default: wrong_model: GB_log(gb, "The save state is for a different model. Try changing the emulated model.\n"); GB_free(&save); return -1; } save.pc = LE16(core.pc); save.af = LE16(core.af); save.bc = LE16(core.bc); save.de = LE16(core.de); save.hl = LE16(core.hl); save.sp = LE16(core.sp); save.ime = core.ime; save.interrupt_enable = core.ie; save.halted = core.execution_mode == 1; save.stopped = core.execution_mode == 2; // Done early for compatibility with 0.14.x GB_write_memory(&save, 0xFF00 + GB_IO_SVBK, core.io_registers[GB_IO_SVBK]); // CPU related // Determines DMG mode GB_write_memory(&save, 0xFF00 + GB_IO_KEY0, core.io_registers[GB_IO_KEY0]); save.boot_rom_finished = core.io_registers[GB_IO_BANK]; GB_write_memory(&save, 0xFF00 + GB_IO_KEY1, core.io_registers[GB_IO_KEY1]); if (save.cgb_mode) { save.cgb_double_speed = core.io_registers[GB_IO_KEY1] & 0x80; save.object_priority = GB_OBJECT_PRIORITY_INDEX; } else { save.object_priority = GB_OBJECT_PRIORITY_X; } // Timers, Joypad and Serial GB_write_memory(&save, 0xFF00 + GB_IO_JOYP, core.io_registers[GB_IO_JOYP]); GB_write_memory(&save, 0xFF00 + GB_IO_SB, core.io_registers[GB_IO_SB]); save.io_registers[GB_IO_SC] = core.io_registers[GB_IO_SC]; save.div_counter = core.io_registers[GB_IO_DIV] << 8; GB_write_memory(&save, 0xFF00 + GB_IO_TIMA, core.io_registers[GB_IO_TIMA]); GB_write_memory(&save, 0xFF00 + GB_IO_TMA, core.io_registers[GB_IO_TMA]); GB_write_memory(&save, 0xFF00 + GB_IO_TAC, core.io_registers[GB_IO_TAC]); // APU GB_write_memory(&save, 0xFF00 + GB_IO_NR52, core.io_registers[GB_IO_NR52]); for (unsigned i = GB_IO_NR10; i < GB_IO_NR52; i++) { uint8_t value = core.io_registers[i]; if (i == GB_IO_NR14 || i == GB_IO_NR24 || i == GB_IO_NR34 || i == GB_IO_NR44) { value &= ~0x80; } GB_write_memory(&save, 0xFF00 + i, value); } for (unsigned i = GB_IO_WAV_START; i <= GB_IO_WAV_END; i++) { GB_write_memory(&save, 0xFF00 + i, core.io_registers[i]); } // PPU GB_write_memory(&save, 0xFF00 + GB_IO_LCDC, core.io_registers[GB_IO_LCDC]); GB_write_memory(&save, 0xFF00 + GB_IO_STAT, core.io_registers[GB_IO_STAT]); GB_write_memory(&save, 0xFF00 + GB_IO_SCY, core.io_registers[GB_IO_SCY]); GB_write_memory(&save, 0xFF00 + GB_IO_SCX, core.io_registers[GB_IO_SCX]); GB_write_memory(&save, 0xFF00 + GB_IO_LYC, core.io_registers[GB_IO_LYC]); save.io_registers[GB_IO_DMA] = core.io_registers[GB_IO_DMA]; GB_write_memory(&save, 0xFF00 + GB_IO_BGP, core.io_registers[GB_IO_BGP]); GB_write_memory(&save, 0xFF00 + GB_IO_OBP0, core.io_registers[GB_IO_OBP0]); GB_write_memory(&save, 0xFF00 + GB_IO_OBP1, core.io_registers[GB_IO_OBP1]); GB_write_memory(&save, 0xFF00 + GB_IO_WX, core.io_registers[GB_IO_WX]); GB_write_memory(&save, 0xFF00 + GB_IO_WY, core.io_registers[GB_IO_WY]); // Other registers GB_write_memory(&save, 0xFF00 + GB_IO_VBK, core.io_registers[GB_IO_VBK]); GB_write_memory(&save, 0xFF00 + GB_IO_HDMA1, core.io_registers[GB_IO_HDMA1]); GB_write_memory(&save, 0xFF00 + GB_IO_HDMA2, core.io_registers[GB_IO_HDMA2]); GB_write_memory(&save, 0xFF00 + GB_IO_HDMA3, core.io_registers[GB_IO_HDMA3]); GB_write_memory(&save, 0xFF00 + GB_IO_HDMA4, core.io_registers[GB_IO_HDMA4]); GB_write_memory(&save, 0xFF00 + GB_IO_RP, core.io_registers[GB_IO_RP]); GB_write_memory(&save, 0xFF00 + GB_IO_BGPI, core.io_registers[GB_IO_BGPI]); GB_write_memory(&save, 0xFF00 + GB_IO_OBPI, core.io_registers[GB_IO_OBPI]); GB_write_memory(&save, 0xFF00 + GB_IO_OPRI, core.io_registers[GB_IO_OPRI]); // Interrupts GB_write_memory(&save, 0xFF00 + GB_IO_IF, core.io_registers[GB_IO_IF]); /* Required to be compatible with both SameBoy 0.14.x AND BGB */ if (GB_is_cgb(&save) && !save.cgb_mode && save.cgb_ram_bank == 7) { save.cgb_ram_bank = 1; } break; case BE32('NAME'): if (LE32(block.size) > sizeof(emulator_name) - 1) { file->seek(file, LE32(block.size), SEEK_CUR); } else { file->read(file, emulator_name, LE32(block.size)); } break; case BE32('INFO'): { BESS_INFO_t bess_info = {0,}; if (LE32(block.size) != sizeof(bess_info) - sizeof(block)) goto parse_error; if (file->read(file, &bess_info.header + 1, LE32(block.size)) != LE32(block.size)) goto error; const uint8_t *bank = get_header_bank(gb); if (memcmp(bess_info.title, bank + 0x134, sizeof(bess_info.title))) { char ascii_title[0x11] = {0,}; for (unsigned i = 0; i < 0x10; i++) { if (bess_info.title[i] < 0x20 || bess_info.title[i] > 0x7E) break; ascii_title[i] = bess_info.title[i]; } GB_log(gb, "Save state was made on another ROM: '%s'\n", ascii_title); } else if (memcmp(bess_info.checksum, bank + 0x14E, 2)) { GB_log(gb, "Save state was potentially made on another revision of the same ROM.\n"); } break; } case BE32('XOAM'): if (!found_core) goto parse_error; if (LE32(block.size) != 96) goto parse_error; file->read(file, save.extra_oam, sizeof(save.extra_oam)); break; case BE32('MBC '): if (!found_core) goto parse_error; if (LE32(block.size) % 3 != 0) goto parse_error; if (LE32(block.size) > 0x1000) goto parse_error; /* Inject some default writes, as some emulators omit them */ if (gb->cartridge_type->mbc_type == GB_MMM01) { GB_write_memory(&save, 0x6000, 0x30); GB_write_memory(&save, 0x4000, 0x70); } for (unsigned i = LE32(block.size); i > 0; i -= 3) { BESS_MBC_pair_t pair; file->read(file, &pair, sizeof(pair)); if (LE16(pair.address) >= 0x8000 && LE16(pair.address) < 0xA000) goto parse_error; if (LE16(pair.address) >= 0xC000) goto parse_error; GB_write_memory(&save, LE16(pair.address), pair.value); } break; case BE32('RTC '): if (!found_core) goto parse_error; BESS_RTC_t bess_rtc; if (LE32(block.size) != sizeof(bess_rtc) - sizeof(block)) goto parse_error; if (file->read(file, &bess_rtc.header + 1, LE32(block.size)) != LE32(block.size)) goto error; if (!gb->cartridge_type->has_rtc || gb->cartridge_type->mbc_type != GB_MBC3) break; save.rtc_real.seconds = bess_rtc.real.seconds; save.rtc_real.minutes = bess_rtc.real.minutes; save.rtc_real.hours = bess_rtc.real.hours; save.rtc_real.days = bess_rtc.real.days; save.rtc_real.high = bess_rtc.real.high; save.rtc_latched.seconds = bess_rtc.latched.seconds; save.rtc_latched.minutes = bess_rtc.latched.minutes; save.rtc_latched.hours = bess_rtc.latched.hours; save.rtc_latched.days = bess_rtc.latched.days; save.rtc_latched.high = bess_rtc.latched.high; if (gb->rtc_mode == GB_RTC_MODE_SYNC_TO_HOST) { save.last_rtc_second = MIN(LE64(bess_rtc.last_rtc_second), time(NULL)); } break; case BE32('HUC3'): if (!found_core) goto parse_error; BESS_HUC3_t bess_huc3; if (LE32(block.size) != sizeof(bess_huc3) - sizeof(block)) goto parse_error; if (file->read(file, &bess_huc3.header + 1, LE32(block.size)) != LE32(block.size)) goto error; if (gb->cartridge_type->mbc_type != GB_HUC3) break; if (gb->rtc_mode == GB_RTC_MODE_SYNC_TO_HOST) { save.last_rtc_second = MIN(LE64(bess_huc3.data.last_rtc_second), time(NULL)); } save.huc3.minutes = LE16(bess_huc3.data.minutes); save.huc3.days = LE16(bess_huc3.data.days); save.huc3.alarm_minutes = LE16(bess_huc3.data.alarm_minutes); save.huc3.alarm_days = LE16(bess_huc3.data.alarm_days); save.huc3.alarm_enabled = bess_huc3.data.alarm_enabled; break; case BE32('TPP1'): if (!found_core) goto parse_error; BESS_TPP1_t bess_tpp1; if (LE32(block.size) != sizeof(bess_tpp1) - sizeof(block)) goto parse_error; if (file->read(file, &bess_tpp1.header + 1, LE32(block.size)) != LE32(block.size)) goto error; if (gb->cartridge_type->mbc_type != GB_TPP1) break; if (gb->rtc_mode == GB_RTC_MODE_SYNC_TO_HOST) { save.last_rtc_second = MIN(LE64(bess_tpp1.last_rtc_second), time(NULL)); } unrolled for (unsigned i = 4; i--;) { save.rtc_real.data[i ^ 3] = bess_tpp1.real_rtc_data[i]; save.rtc_latched.data[i ^ 3] = bess_tpp1.latched_rtc_data[i]; } save.tpp1_mr4 = bess_tpp1.mr4; break; case BE32('SGB '): if (!found_core) goto parse_error; if (!gb->sgb) goto parse_error; if (LE32(block.size) > sizeof(sgb) - sizeof(block)) { if (file->read(file, &sgb.header + 1, sizeof(sgb) - sizeof(block)) != sizeof(sgb) - sizeof(block)) goto error; file->seek(file, LE32(block.size) - (sizeof(sgb) - sizeof(block)), SEEK_CUR); } else { if (file->read(file, &sgb.header + 1, LE32(block.size)) != LE32(block.size)) goto error; } found_sgb = true; break; case BE32('END '): if (!found_core) goto parse_error; if (LE32(block.size) != 0) goto parse_error; goto done; default: file->seek(file, LE32(block.size), SEEK_CUR); break; } } done: save.mbc_ram_size = gb->mbc_ram_size; memcpy(gb, &save, GB_SECTION_OFFSET(unsaved)); assert(GB_get_save_state_size(gb) == GB_get_save_state_size(&save)); GB_free(&save); read_bess_buffer(&core.ram, file, gb->ram, gb->ram_size); read_bess_buffer(&core.vram, file, gb->vram, gb->vram_size); read_bess_buffer(&core.mbc_ram, file, gb->mbc_ram, gb->mbc_ram_size); read_bess_buffer(&core.oam, file, gb->oam, sizeof(gb->oam)); read_bess_buffer(&core.hram, file, gb->hram, sizeof(gb->hram)); read_bess_buffer(&core.background_palettes, file, gb->background_palettes_data, sizeof(gb->background_palettes_data)); read_bess_buffer(&core.object_palettes, file, gb->object_palettes_data, sizeof(gb->object_palettes_data)); if (gb->sgb) { memset(gb->sgb, 0, sizeof(*gb->sgb)); GB_sgb_load_default_data(gb); if (gb->boot_rom_finished) { gb->sgb->intro_animation = GB_SGB_INTRO_ANIMATION_LENGTH; if (!found_sgb) { gb->sgb->disable_commands = true; } else { read_bess_buffer(&sgb.border_tiles, file, gb->sgb->border.tiles, sizeof(gb->sgb->border.tiles)); read_bess_buffer(&sgb.border_tilemap, file, (void *)gb->sgb->border.map, sizeof(gb->sgb->border.map)); read_bess_buffer(&sgb.border_palettes, file, (void *)gb->sgb->border.palette, sizeof(gb->sgb->border.palette)); read_bess_buffer(&sgb.active_palettes, file, (void *)gb->sgb->effective_palettes, sizeof(gb->sgb->effective_palettes)); read_bess_buffer(&sgb.ram_palettes, file, (void *)gb->sgb->ram_palettes, sizeof(gb->sgb->ram_palettes)); read_bess_buffer(&sgb.attribute_map, file, (void *)gb->sgb->attribute_map, sizeof(gb->sgb->attribute_map)); read_bess_buffer(&sgb.attribute_files, file, (void *)gb->sgb->attribute_files, sizeof(gb->sgb->attribute_files)); gb->sgb->effective_palettes[12] = gb->sgb->effective_palettes[8] = gb->sgb->effective_palettes[4] = gb->sgb->effective_palettes[0]; gb->sgb->player_count = sgb.multiplayer_state >> 4; gb->sgb->current_player = sgb.multiplayer_state & 0xF; if (gb->sgb->player_count > 4 || gb->sgb->player_count == 3 || gb->sgb->player_count == 0) { gb->sgb->player_count = 1; gb->sgb->current_player = 0; } } } else { // Effectively reset if didn't finish the boot ROM gb->pc = 0; } } if (emulator_name[0]) { GB_log(gb, "Save state imported from %s.\n", emulator_name); } else { GB_log(gb, "Save state imported from another emulator.\n"); // SameBoy always contains a NAME block } for (unsigned i = 0; i < 32; i++) { GB_palette_changed(gb, false, i * 2); GB_palette_changed(gb, true, i * 2); } return 0; parse_error: errno = -1; error: if (emulator_name[0]) { GB_log(gb, "Attempted to import a save state from %s, but the save state is invalid.\n", emulator_name); } else { GB_log(gb, "Attempted to import a save state from a different emulator or incompatible version, but the save state is invalid.\n"); } GB_free(&save); sanitize_state(gb); return errno; } static int load_state_internal(GB_gameboy_t *gb, virtual_file_t *file) { GB_gameboy_t save; /* Every unread value should be kept the same. */ memcpy(&save, gb, sizeof(save)); /* ...Except ram size, we use it to detect old saves with incorrect ram sizes */ save.ram_size = 0; bool fix_broken_windows_saves = false; if (file->read(file, GB_GET_SECTION(&save, header), GB_SECTION_SIZE(header)) != GB_SECTION_SIZE(header)) return errno; if (save.magic == 0) { /* Potentially legacy, broken Windows save state*/ file->seek(file, 4, SEEK_SET); if (file->read(file, GB_GET_SECTION(&save, header), GB_SECTION_SIZE(header)) != GB_SECTION_SIZE(header)) return errno; fix_broken_windows_saves = true; } if (gb->magic != save.magic) { return load_bess_save(gb, file, false); } #define READ_SECTION(gb, file, section) read_section(file, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section), fix_broken_windows_saves) if (!READ_SECTION(&save, file, core_state)) return errno ?: EIO; if (!READ_SECTION(&save, file, dma )) return errno ?: EIO; if (!READ_SECTION(&save, file, mbc )) return errno ?: EIO; if (!READ_SECTION(&save, file, hram )) return errno ?: EIO; if (!READ_SECTION(&save, file, timing )) return errno ?: EIO; if (!READ_SECTION(&save, file, apu )) return errno ?: EIO; if (!READ_SECTION(&save, file, rtc )) return errno ?: EIO; if (!READ_SECTION(&save, file, video )) return errno ?: EIO; #undef READ_SECTION bool attempt_bess = false; if (!verify_and_update_state_compatibility(gb, &save, &attempt_bess)) { if (attempt_bess) { return load_bess_save(gb, file, true); } return errno; } if (GB_is_hle_sgb(gb)) { if (!read_section(file, gb->sgb, sizeof(*gb->sgb), false)) return errno ?: EIO; } memset(gb->mbc_ram + save.mbc_ram_size, 0xFF, gb->mbc_ram_size - save.mbc_ram_size); if (file->read(file, gb->mbc_ram, save.mbc_ram_size) != save.mbc_ram_size) { return errno ?: EIO; } if (file->read(file, gb->ram, gb->ram_size) != gb->ram_size) { return errno ?: EIO; } /* Fix for 0.11 save states that allocate twice the amount of RAM in CGB instances */ file->seek(file, save.ram_size - gb->ram_size, SEEK_CUR); if (file->read(file, gb->vram, gb->vram_size) != gb->vram_size) { return errno ?: EIO; } size_t orig_ram_size = gb->ram_size; memcpy(gb, &save, sizeof(save)); gb->ram_size = orig_ram_size; sanitize_state(gb); return 0; } int GB_load_state(GB_gameboy_t *gb, const char *path) { FILE *f = fopen(path, "rb"); if (!f) { GB_log(gb, "Could not open save state: %s.\n", strerror(errno)); return errno; } virtual_file_t file = { .read = file_read, .seek = file_seek, .tell = file_tell, .file = f, }; int ret = load_state_internal(gb, &file); fclose(f); return ret; } int GB_load_state_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t length) { virtual_file_t file = { .read = buffer_read, .seek = buffer_seek, .tell = buffer_tell, .buffer = (uint8_t *)buffer, .position = 0, .size = length, }; return load_state_internal(gb, &file); } bool GB_is_save_state(const char *path) { bool ret = false; FILE *f = fopen(path, "rb"); if (!f) return false; uint32_t magic = 0; fread(&magic, sizeof(magic), 1, f); if (magic == state_magic()) { ret = true; goto exit; } // Legacy corrupted Windows save state if (magic == 0) { fread(&magic, sizeof(magic), 1, f); if (magic == state_magic()) { ret = true; goto exit; } } fseek(f, -sizeof(magic), SEEK_END); fread(&magic, sizeof(magic), 1, f); if (magic == BE32('BESS')) { ret = true; } exit: fclose(f); return ret; }