Initial BESS support, no SGB nor RTC yet

Cocoa/Document.m

@@ -1181,11 +1181,11 @@ static unsigned *multiplication_table_for_frequency(unsigned frequency)
     }];
     
     if (!success) {
-        if (error) {
-            [GBWarningPopover popoverWithContents:error onWindow:self.mainWindow];
-        }
         NSBeep();
     }
+    if (error) {
+        [GBWarningPopover popoverWithContents:error onWindow:self.mainWindow];
+    }
 }
 
 - (IBAction)clearConsole:(id)sender

Core/save_state.c

@@ -1,6 +1,88 @@
 #include "gb.h"
 #include <stdio.h>
 #include <errno.h>
+#include <assert.h>
+
+#define str(x) #x
+#define xstr(x) str(x)
+#ifdef GB_BIG_ENDIAN
+#define BESS_NAME "SameBoy v" xstr(VERSION) "(Big Endian)"
+#else
+#define BESS_NAME "SameBoy v" xstr(VERSION)
+#endif
+
+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 io_registers[0x80];
+    uint8_t hram[0x7f];
+    
+    BESS_buffer_t ram;
+    BESS_buffer_t vram;
+    BESS_buffer_t mbc_ram;
+} BESS_CORE_t;
+
+typedef struct __attribute__((packed)) {
+    BESS_block_t header;
+    uint8_t oam[256];
+} BESS_OAM_t;
+
+typedef struct __attribute__((packed)) {
+    BESS_block_t header;
+    uint8_t background_palettes[0x40];
+    uint8_t sprite_palettes[0x40];
+} BESS_PALS_t;
+
+typedef struct  __attribute__((packed)) {
+    uint16_t address;
+    uint8_t value;
+} BESS_MBC_pair_t;
+
+
+#ifdef GB_BIG_ENDIAN
+#define BESS16(x) __builtin_bswap16(x)
+#define BESS32(x) __builtin_bswap32(x)
+#else
+#define BESS16(x) (x)
+#define BESS32(x) (x)
+#endif
 
 typedef struct virtual_file_s virtual_file_t;
 struct virtual_file_s
@@ -8,6 +90,7 @@ 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 {
@@ -33,8 +116,16 @@ 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;
@@ -75,6 +166,31 @@ static size_t buffer_write(virtual_file_t *file, const void *src, size_t 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) + 4 * sizeof(BESS_MBC_pair_t);
+        case GB_MBC5:
+            return sizeof(BESS_block_t) + 4 * 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);
+    }
+}
+
 size_t GB_get_save_state_size(GB_gameboy_t *gb)
 {
     return GB_SECTION_SIZE(header)
@@ -89,11 +205,21 @@ size_t GB_get_save_state_size(GB_gameboy_t *gb)
     + (GB_is_hle_sgb(gb)? sizeof(*gb->sgb) + sizeof(uint32_t) : 0)
     + gb->mbc_ram_size
     + gb->ram_size
-    + gb->vram_size;
+    + gb->vram_size
+    // BESS
+    + sizeof(BESS_CORE_t)
+    + sizeof(BESS_block_t) // NAME
+    + sizeof(BESS_NAME) - 1
+    + sizeof(BESS_OAM_t)
+    + (GB_is_cgb(gb)? sizeof(BESS_PALS_t) : 0)
+    + bess_size_for_cartridge(gb->cartridge_type) // MBC 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)
+static bool verify_and_update_state_compatibility(GB_gameboy_t *gb, GB_gameboy_t *save, bool *attempt_bess)
 {
+    *attempt_bess = false;
     if (save->ram_size == 0 && (&save->ram_size)[-1] == gb->ram_size) {
         /* This is a save state with a bad printer struct from a 32-bit OS */
         memmove(save->extra_oam + 4, save->extra_oam, (uintptr_t)&save->ram_size - (uintptr_t)&save->extra_oam);
@@ -121,6 +247,7 @@ static bool verify_and_update_state_compatibility(GB_gameboy_t *gb, GB_gameboy_t
     
     if (gb->version != save->version) {
         GB_log(gb, "The save state is for a different version of SameBoy.\n");
+        *attempt_bess = true;
         return false;
     }
     
@@ -190,6 +317,66 @@ static bool dump_section(virtual_file_t *file, const void *src, uint32_t size)
 
 #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 = {htonl('MBC '), 0};
+    BESS_MBC_pair_t pairs[4];
+    switch (gb->cartridge_type->mbc_type) {
+        default:
+        case GB_NO_MBC: return 0;
+        case GB_MBC1:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->mbc_ram_enable? 0xA : 0x0};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x2000), gb->mbc1.bank_low};
+            pairs[2] = (BESS_MBC_pair_t){BESS16(0x4000), gb->mbc1.bank_high};
+            pairs[3] = (BESS_MBC_pair_t){BESS16(0x6000), gb->mbc1.mode};
+            mbc_block.size = 4 * sizeof(pairs[0]);
+            break;
+        case GB_MBC2:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->mbc_ram_enable? 0xA : 0x0};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x0100), gb->mbc2.rom_bank};
+            mbc_block.size = 2 * sizeof(pairs[0]);
+            break;
+        case GB_MBC3:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->mbc_ram_enable? 0xA : 0x0};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x2000), gb->mbc3.rom_bank};
+            pairs[2] = (BESS_MBC_pair_t){BESS16(0x4000), gb->mbc3.ram_bank | (gb->mbc3_rtc_mapped? 8 : 0)};
+            pairs[3] = (BESS_MBC_pair_t){BESS16(0x6000), gb->rtc_latch};
+            mbc_block.size = 4 * sizeof(pairs[0]);
+            break;
+        case GB_MBC5:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->mbc_ram_enable? 0xA : 0x0};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x2000), gb->mbc5.rom_bank_low};
+            pairs[2] = (BESS_MBC_pair_t){BESS16(0x3000), gb->mbc5.rom_bank_high};
+            pairs[3] = (BESS_MBC_pair_t){BESS16(0x4000), gb->mbc5.ram_bank};
+            mbc_block.size = 4 * sizeof(pairs[0]);
+            break;
+        case GB_HUC1:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->huc1.ir_mode? 0xE : 0x0};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x2000), gb->huc1.bank_low};
+            pairs[2] = (BESS_MBC_pair_t){BESS16(0x4000), gb->huc1.bank_high};
+            pairs[3] = (BESS_MBC_pair_t){BESS16(0x6000), gb->huc1.mode};
+            mbc_block.size = 4 * sizeof(pairs[0]);
+            
+        case GB_HUC3:
+            pairs[0] = (BESS_MBC_pair_t){BESS16(0x0000), gb->huc3_mode};
+            pairs[1] = (BESS_MBC_pair_t){BESS16(0x2000), gb->huc3.rom_bank};
+            pairs[2] = (BESS_MBC_pair_t){BESS16(0x4000), gb->huc3.ram_bank};
+            mbc_block.size = 3 * sizeof(pairs[0]);
+            break;
+    }
+    
+    if (file->write(file, &mbc_block, sizeof(mbc_block)) != sizeof(mbc_block)) {
+        return errno;
+    }
+    
+    if (file->write(file, &pairs, mbc_block.size) != mbc_block.size) {
+        return errno;
+    }
+    
+    return 0;
+}
+
 static int save_state_internal(GB_gameboy_t *gb, virtual_file_t *file)
 {
     if (file->write(file, GB_GET_SECTION(gb, header), GB_SECTION_SIZE(header)) != GB_SECTION_SIZE(header)) goto error;
@@ -206,20 +393,139 @@ static int save_state_internal(GB_gameboy_t *gb, virtual_file_t *file)
         if (!dump_section(file, gb->sgb, sizeof(*gb->sgb))) goto error;
     }
     
+    BESS_CORE_t bess_core;
+    
+    bess_core.mbc_ram.offset = file->tell(file);
+    bess_core.mbc_ram.size = 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 = file->tell(file);
+    bess_core.ram.size = gb->ram_size;
     if (file->write(file, gb->ram, gb->ram_size) != gb->ram_size) {
         goto error;
     }
     
+    bess_core.vram.offset = file->tell(file);
+    bess_core.vram.size = gb->vram_size;
     if (file->write(file, gb->vram, gb->vram_size) != gb->vram_size) {
         goto error;
     }
     
-    errno = 0;
+    BESS_footer_t bess_footer = {
+        .start_offset = file->tell(file),
+        .magic = htonl('BESS'),
+    };
     
+    /* BESS CORE */
+    
+    bess_core.header = (BESS_block_t){htonl('CORE'), BESS32(sizeof(bess_core) - sizeof(bess_core.header))};
+    bess_core.major = BESS16(1);
+    bess_core.minor = BESS16(1);
+    switch (gb->model) {
+
+        case GB_MODEL_DMG_B: bess_core.full_model = htonl('GDB '); break;
+            
+        case GB_MODEL_SGB_NTSC:
+        case GB_MODEL_SGB_NTSC_NO_SFC:
+            bess_core.full_model = htonl('SN  '); break;
+            
+        case GB_MODEL_SGB_PAL_NO_SFC:
+        case GB_MODEL_SGB_PAL:
+            bess_core.full_model = htonl('SP  '); break;
+        
+        case GB_MODEL_SGB2_NO_SFC:
+        case GB_MODEL_SGB2:
+            bess_core.full_model = htonl('S2  '); break;
+ 
+ 
+        case GB_MODEL_CGB_C: bess_core.full_model = htonl('CCC '); break;
+        case GB_MODEL_CGB_E: bess_core.full_model = htonl('CCE '); break;
+        case GB_MODEL_AGB: bess_core.full_model = htonl('CA  '); break; // SameBoy doesn't emulate a specific AGB revision yet
+    }
+    
+    bess_core.pc = BESS16(gb->pc);
+    bess_core.af = BESS16(gb->af);
+    bess_core.bc = BESS16(gb->bc);
+    bess_core.de = BESS16(gb->de);
+    bess_core.hl = BESS16(gb->hl);
+    bess_core.sp = BESS16(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;
+    memcpy(bess_core.hram, gb->hram, sizeof(gb->hram));
+    
+    
+    if (file->write(file, &bess_core, sizeof(bess_core)) != sizeof(bess_core)) {
+        goto error;
+    }
+    
+    /* BESS NAME */
+    
+    static const BESS_block_t bess_name = {htonl('NAME'), BESS32(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 OAM */
+    
+    BESS_OAM_t bess_oam;
+    bess_oam.header = (BESS_block_t){htonl('OAM '), BESS32(sizeof(bess_oam) - sizeof(bess_oam.header))};
+    memcpy(bess_oam.oam, gb->oam, sizeof(gb->oam));
+    memcpy(bess_oam.oam + sizeof(gb->oam), gb->extra_oam, sizeof(gb->extra_oam));
+    
+    if (file->write(file, &bess_oam, sizeof(bess_oam)) != sizeof(bess_oam)) {
+        goto error;
+    }
+    
+    save_bess_mbc_block(gb, file);
+    
+    if (GB_is_cgb(gb)) {
+        /* BESS PALS */
+        
+        BESS_PALS_t bess_pals;
+        bess_pals.header = (BESS_block_t){htonl('PALS'), BESS32(sizeof(bess_pals) - sizeof(bess_oam.header))};
+        memcpy(bess_pals.background_palettes, gb->background_palettes_data, sizeof(bess_pals.background_palettes));
+        memcpy(bess_pals.sprite_palettes, gb->sprite_palettes_data, sizeof(bess_pals.sprite_palettes));
+
+        if (file->write(file, &bess_pals, sizeof(bess_pals)) != sizeof(bess_pals)) {
+            goto error;
+        }
+    }
+    
+    /* BESS END */
+    
+    static const BESS_block_t bess_end = {htonl('END '), 0};
+
+    if (file->write(file, &bess_end, sizeof(bess_end)) != sizeof(bess_end)) {
+        goto error;
+    }
+    
+    /* BESS Footer */
+    
+    if (file->write(file, &bess_footer, sizeof(bess_footer)) != sizeof(bess_footer)) {
+        goto error;
+    }
+    
+    errno = 0;
 error:
     return errno;
 }
@@ -234,6 +540,7 @@ int GB_save_state(GB_gameboy_t *gb, const char *path)
     virtual_file_t file = {
         .write = file_write,
         .seek = file_seek,
+        .tell = file_tell,
         .file = f,
     };
     int ret = save_state_internal(gb, &file);
@@ -246,11 +553,13 @@ 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);
+    assert(file.position == GB_get_save_state_size(gb));
 }
 
 
@@ -284,6 +593,229 @@ static bool read_section(virtual_file_t *file, void *dest, uint32_t size, bool f
     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, BESS32(buffer->offset), SEEK_SET);
+    file->read(file, dest, MIN(BESS32(buffer->size), max_size));
+    file->seek(file, pos, SEEK_SET);
+}
+
+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 != htonl('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, BESS32(footer.start_offset), SEEK_SET);
+    bool found_core = false;
+    BESS_CORE_t core;
+    while (true) {
+        BESS_block_t block;
+        if (file->read(file, &block, sizeof(block)) != sizeof(block)) goto error;
+        switch (block.magic) {
+            case htonl('CORE'):
+                if (found_core) goto parse_error;
+                found_core = true;
+                if (BESS32(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, BESS32(block.size) - (sizeof(core) - sizeof(block)), SEEK_CUR);
+                }
+                else {
+                    if (file->read(file, &core.header + 1, BESS32(block.size)) != BESS32(block.size)) goto error;
+                }
+                
+                if (core.major != BESS16(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 = BESS16(core.pc);
+                save.af = BESS16(core.af);
+                save.bc = BESS16(core.bc);
+                save.de = BESS16(core.de);
+                save.hl = BESS16(core.hl);
+                save.sp = BESS16(core.sp);
+                
+                save.ime = core.ime;
+                save.interrupt_enable = core.ie;
+                
+                save.halted = core.execution_mode == 1;
+                save.stopped = core.execution_mode == 2;
+                
+                memcpy(save.hram, core.hram, sizeof(save.hram));
+                
+                // 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]);
+                GB_write_memory(&save, 0xFF00 + GB_IO_SVBK, core.io_registers[GB_IO_SVBK]);
+
+                // Interrupts
+                GB_write_memory(&save, 0xFF00 + GB_IO_IF, core.io_registers[GB_IO_IF]);
+                
+                break;
+            case htonl('NAME'):
+                if (!found_core) goto parse_error;
+                if (BESS32(block.size) > sizeof(emulator_name) - 1) {
+                    file->seek(file, BESS32(block.size), SEEK_CUR);
+                }
+                else {
+                    file->read(file, emulator_name, BESS32(block.size));
+                }
+                break;
+            case htonl('OAM '):
+                if (!found_core) goto parse_error;
+                if (BESS32(block.size) != 256 && BESS32(block.size) != 160) goto parse_error;
+                file->read(file, save.oam, sizeof(save.oam));
+                if (BESS32(block.size) == 256) {
+                    file->read(file, save.extra_oam, sizeof(save.extra_oam));
+                }
+                break;
+            case htonl('PALS'):
+                if (!found_core) goto parse_error;
+                if (BESS32(block.size) != sizeof(BESS_PALS_t) - sizeof(block)) goto parse_error;
+                file->read(file, save.background_palettes_data, sizeof(save.background_palettes_data));
+                file->read(file, save.sprite_palettes_data, sizeof(save.sprite_palettes_data));
+                break;
+            case htonl('MBC '):
+                if (!found_core) goto parse_error;
+                if (BESS32(block.size) % 3 != 0) goto parse_error;
+                for (unsigned i = BESS32(block.size); i > 0;  i -= 3) {
+                    BESS_MBC_pair_t pair;
+                    file->read(file, &pair, sizeof(pair));
+                    if (BESS16(pair.address) >= 0x8000) goto parse_error;
+                    GB_write_memory(&save, BESS16(pair.address), pair.value);
+                }
+                break;
+            case htonl('END '):
+                if (!found_core) goto parse_error;
+                if (BESS32(block.size) != 0) goto parse_error;
+                goto done;
+            default:
+                file->seek(file, BESS32(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);
+    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);
+    return errno;
+}
+
 static int load_state_internal(GB_gameboy_t *gb, virtual_file_t *file)
 {
     GB_gameboy_t save;
@@ -304,8 +836,7 @@ static int load_state_internal(GB_gameboy_t *gb, virtual_file_t *file)
         fix_broken_windows_saves = true;
     }
     if (gb->magic != save.magic) {
-        GB_log(gb, "The file is not a save state, or is from an incompatible operating system.\n");
+        return load_bess_save(gb, file, false);
-        return 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;
@@ -319,7 +850,11 @@ static int load_state_internal(GB_gameboy_t *gb, virtual_file_t *file)
 #undef READ_SECTION
     
     
-    if (!verify_and_update_state_compatibility(gb, &save)) {
+    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;
     }
     
@@ -362,6 +897,7 @@ int GB_load_state(GB_gameboy_t *gb, const char *path)
     virtual_file_t file = {
         .read = file_read,
         .seek = file_seek,
+        .tell = file_tell,
         .file = f,
     };
     int ret = load_state_internal(gb, &file);
@@ -374,6 +910,7 @@ int GB_load_state_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t le
     virtual_file_t file = {
         .read = buffer_read,
         .seek = buffer_seek,
+        .tell = buffer_tell,
         .buffer = (uint8_t *)buffer,
         .position = 0,
         .size = length,