Emulation/lsnes
1
0
Fork 0
mirror of https://github.com/rodamaral/lsnes.git synced 2025-04-02 10:42:15 -04:00
Code Issues Projects Releases Packages Wiki Activity
lsnes/core-freestanding.cpp

1505 lines
44 KiB
C++
Raw Permalink Blame History

#include <cstddef>
#include <functional>
#include <iostream>
#include <iomanip>
#include <sstream>
#include "c-interface-translate.hpp"
#define PROFILE_COMPATIBILITY
#define DEBUGGER
#include "snes/snes.hpp"
#include "gameboy/gameboy.hpp"
#include "snes/chip/icd2/gameboy.hpp"
#include "gameboy/gameboy.hpp"
#include "ui-libsnes/libsnes.hpp"
#define HAVE_CSTDINT
#include "libgambatte/include/gambatte.h"
namespace
{
bool disable_breakpoints = false; //Breakpoint temporary disable.
gambatte::GB* gb_instance; //Gambatte instance to use.
bool trace_cpu_enable = false; //True if tracing S-CPU is enabled.
bool trace_smp_enable = false; //True if tracing S-SMP is enabled.
unsigned delayreset_cycles_run = 0; //Number of cycles already ran for delay reset.
unsigned delayreset_cycles_target = 0; //Number of cycles to run for delay reset.
bool video_refresh_done = false; //Set to false on start of frame, set to true on video refresh.
bool forced_hook = false; //True if there is forced SNES hook function.
std::string core_bsnes_gambatte_name; //Name of core.
bool gb_raw_signal_enabled = false; //If to enable GB raw signal display.
uint32_t gb_raw_signal[160*144]; //The GB raw signal display.
uint64_t gb_tsc; //Gameboy TSC.
#include "tempmem.hpp"
#include "callbacks.hpp"
#include "controllerjson.hpp"
#include "memregions.hpp"
#include "registers.hpp"
#include "strfmt.hpp"
#include "gbdisasm.hpp"
#include "debug.hpp"
#include "sram.hpp"
#include "serialize.hpp"
using lsnes_interface::e2t;
//Interface functions return error, so NULL is success.
#define RET_OK NULL
#define def_sysregion_sgb_ntsc 0
#define def_core_bsnes_gambatte 0
#define def_region_ntsc 0
#define def_type_supergameboy 0
#define LSNES_END_LIST 0xFFFFFFFFU
#define TMP_ERROR 0
#define TMP_AUDIO 1
#define TMP_TXTBMP 2
#define TMP_TEXT 3
#define TMP_VIDEO 4
#define TMP_UNSPEC 5
#define DURATION_NTSC_FRAME 357366
#define DURATION_NTSC_FIELD 357368
#define CASE_CALL(X) \
case X : \
ret = interface(item, *(e2t<X>::t)params); \
break
#define CASE_CALL_NOITEM(X) \
case X : \
ret = interface(*(e2t<X>::t)params); \
break
#define EMIT_SUBCASE(X, I) \
case def_##I : \
ret = I (*(e2t<X>::t)params); \
break
#define CASE_CALL_CORE(X) \
case X : \
switch(item) { \
EMIT_SUBCASE(X, core_bsnes_gambatte ); \
default: \
ret = complain_unknown_core(item); \
break; \
} \
break
#define CASE_CALL_TYPE(X) \
case X : \
switch(item) { \
EMIT_SUBCASE(X, type_supergameboy ); \
default: \
ret = complain_unknown_type(item); \
break; \
} \
break
#define CASE_CALL_REGION(X) \
case X : \
switch(item) { \
EMIT_SUBCASE(X, region_ntsc ); \
default: \
ret = complain_unknown_type(item); \
break; \
} \
break
#define CASE_CALL_SYSREGION(X) \
case X : \
switch(item) { \
EMIT_SUBCASE(X, sysregion_sgb_ntsc ); \
default: \
ret = complain_unknown_type(item); \
break; \
} \
break
unsigned sysregions_supported[] = { def_sysregion_sgb_ntsc, LSNES_END_LIST };
const char* trace_cpu_list[] = {"S-CPU", "S-SMP", "GB-CPU", NULL};
static unsigned compat_regions_ntsc[] = {def_region_ntsc, LSNES_END_LIST};
unsigned regions_sgb[] = {def_region_ntsc, LSNES_END_LIST};
unsigned controller_count[] = {0, 1, 1, 4, 4, 1, 1, 2, 1, 2};
lsnes_core_get_core_info_aparam delayparam[] = {
{"delay", "int:0,999999999"},
{NULL, NULL}
};
lsnes_core_get_core_info_aparam checkparam[] = {
{"", "toggle"},
{NULL, NULL}
};
lsnes_core_get_core_info_action actions_list[] = {
{0, "reset", "Soft reset", NULL},
{1, "hardreset", "Hard reset", NULL},
{2, "delayreset", "Delayed soft reset", delayparam},
{3, "delayhardreset", "Delayed hard reset", delayparam},
{4, "bg1pri0", "Layers‣BG1 Priority 0", checkparam},
{5, "bg1pri1", "Layers‣BG1 Priority 1", checkparam},
{8, "bg2pri0", "Layers‣BG2 Priority 0", checkparam},
{9, "bg2pri1", "Layers‣BG2 Priority 1", checkparam},
{12, "bg3pri0", "Layers‣BG3 Priority 0", checkparam},
{13, "bg3pri1", "Layers‣BG3 Priority 1", checkparam},
{16, "bg4pri0", "Layers‣BG4 Priority 0", checkparam},
{17, "bg4pri1", "Layers‣BG4 Priority 1", checkparam},
{20, "oampri0", "Layers‣Sprite Priority 0", checkparam},
{21, "oampri1", "Layers‣Sprite Priority 1", checkparam},
{22, "oampri2", "Layers‣Sprite Priority 2", checkparam},
{23, "oampri3", "Layers‣Sprite Priority 3", checkparam},
{-1, NULL, NULL, NULL}
};
lsnes_core_get_type_info_romimage sgb_images[] = {
{"rom", "SGB BIOS", 1, 0, 512, "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
{"dmg", "DMG ROM", 2, 0, 512, "gb;dmg;sgb"},
{NULL, NULL, 0, 0, 0, NULL}
};
lsnes_core_get_type_info_paramval boolean_values[] = {
{"0", "false", 0},
{"1", "true", 1},
{NULL, NULL, -1}
};
lsnes_core_get_type_info_paramval port1_values[] = {
{"none", "None", 0},
{"gamepad", "Gamepad", 1},
{"gamepad16", "Gamepad (16-button)", 2},
{"ygamepad16", "Y-cabled gamepad (16-button)", 9},
{"multitap", "Multitap", 3},
{"multitap16", "Multitap (16-button)", 4},
{"mouse", "Mouse", 5},
{NULL, NULL, -1}
};
lsnes_core_get_type_info_paramval port2_values[] = {
{"none", "None", 0},
{"gamepad", "Gamepad", 1},
{"gamepad16", "Gamepad (16-button)", 2},
{"ygamepad16", "Y-cabled gamepad (16-button)", 9},
{"multitap", "Multitap", 3},
{"multitap16", "Multitap (16-button)", 4},
{"mouse", "Mouse", 5},
{"superscope", "Super Scope", 8},
{"justifier", "Justifier", 6},
{"justifiers", "2 Justifiers", 7},
{NULL, NULL, -1}
};
lsnes_core_get_type_info_param bsnes_gambatte_settings[] = {
{"port1", "Port 1 Type", "gamepad", port1_values, NULL},
{"port2", "Port 2 Type", "none", port2_values, NULL},
{"saveevery", "Emulate saving each frame", "0", boolean_values, NULL},
{"radominit", "Random initial state", "0", boolean_values, NULL},
{NULL, NULL, NULL, NULL, NULL}
};
//Variables
bool last_interlace = false; //Last frame was interlaced.
int internal_rom = -1; //Internal ROM type.
SNES::Interface* old = NULL; //Old SNES interface object.
bool port_is_ycable[2]; //Port has Y-Cable connected flags for both ports.
int16_t soundbuf[8192] = {0}; //Sound buffer.
size_t soundbuf_fill = 0; //Amount of data in sound buffer.
bool stepping_into_save = false; //Set when running to save point, false otherwise.
bool have_saved_this_frame = false; //True if state has been saved this frame.
int do_reset_flag = -1; //Number of cycles to next reset (<0 if no reset).
bool do_hreset_flag = false; //True if next reset will be hard.
bool last_hires = false; //Last frame was hires.
bool save_every_frame = false; //True to emulate saving each frame.
bool reallocate_debug = true; //Next load will reallocate debug buffers.
gambatte::debugbuffer debugbuf; //Gambatte debug buffer.
size_t gb_cur_romsize; //Current GB ROM size.
size_t gb_cur_ramsize; //Current GB RAM size.
bool rtc_fixed; //RTC fixed?
time_t rtc_fixed_val; //Value RTC is fixed to.
std::vector<unsigned char> gb_romdata; //Gameboy ROM data.
unsigned current_ly; //Current gameboy LY.
uint8_t mlt_req; //Mlt_req value for SGB.
uint16_t current_scanline[160]; //Current scanline buffer (converted).
uint8_t sgb_button_state; //Current button state from SNES.
uint8_t last_fdiv; //Last frequency divider.
uint8_t p1_value;
bool pflag; //Polled flag.
bool pending_poll; //Poll is pending.
GameBoy::Interface* bsnes_if; //BSNES GB interface.
const char* complain_unknown_item(const char* itype, unsigned item)
{
return tmp_sprintf(TMP_ERROR, "Unknown %s type %u", itype, item);
}
const char* complain_unknown_core(unsigned type)
{
return complain_unknown_item("core", type);
}
const char* complain_unknown_type(unsigned type)
{
return complain_unknown_item("type", type);
}
const char* complain_unknown_region(unsigned type)
{
return complain_unknown_item("region", type);
}
const char* complain_unknown_sysregion(unsigned type)
{
return complain_unknown_item("sysregion", type);
}
lsnes_core_get_controllerconfig_logical_entry mklcid(unsigned p, unsigned c)
{
lsnes_core_get_controllerconfig_logical_entry e;
e.port = p;
e.controller = c;
return e;
}
struct settings_decoded
{
settings_decoded(lsnes_core_system_setting* settings)
{
type1 = 1;
type2 = 0;
esave = 0;
irandom = 0;
for(lsnes_core_system_setting* i = settings; i->name; i++) {
signed settings_decoded::*ptr = NULL;
if(!strcmp(i->name, "port1")) ptr = &settings_decoded::type1;
if(!strcmp(i->name, "port2")) ptr = &settings_decoded::type2;
if(!strcmp(i->name, "saveevery")) ptr = &settings_decoded::esave;
if(!strcmp(i->name, "radominit")) ptr = &settings_decoded::irandom;
for(lsnes_core_get_type_info_param* j = bsnes_gambatte_settings; j->iname; j++) {
if(!strcmp(j->iname, i->name)) {
for(lsnes_core_get_type_info_paramval* k = j->values; k->iname; k++) {
if(!strcmp(k->iname, i->value))
this->*ptr = k->index;
}
}
}
}
}
signed type1;
signed type2;
signed esave;
signed irandom;
};
struct bsnes_interface : public SNES::Interface
{
string path(SNES::Cartridge::Slot slot, const string &hint)
{
const char* _hint = hint;
std::string _hint2 = _hint;
std::string fwp = cb_get_firmware_path();
std::string finalpath = fwp + "/" + _hint2;
return finalpath.c_str();
}
time_t currentTime()
{
return cb_get_time();
}
time_t randomSeed()
{
return cb_get_randomseed();
}
void notifyLatched()
{
cb_notify_latch(NULL);
}
void videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan);
void audioSample(int16_t l_sample, int16_t r_sample)
{
soundbuf[soundbuf_fill++] = l_sample;
soundbuf[soundbuf_fill++] = r_sample;
//The SMP emits a sample every 768 ticks of its clock. Use this in order to keep track of
//time.
cb_timer_tick(768, SNES::system.apu_frequency());
}
int16_t inputPoll(bool port, SNES::Input::Device device, unsigned index, unsigned id)
{
if(port_is_ycable[port ? 1 : 0]) {
int16_t bit0 = cb_get_input(port ? 2 : 1, 0, id);
int16_t bit1 = cb_get_input(port ? 2 : 1, 1, id);
return bit0 + 2 * bit1;
}
int16_t offset = 0;
//The superscope/justifier handling is nuts.
if(port && SNES::input.port2) {
SNES::SuperScope* ss = dynamic_cast<SNES::SuperScope*>(SNES::input.port2);
SNES::Justifier* js = dynamic_cast<SNES::Justifier*>(SNES::input.port2);
if(ss && index == 0) {
if(id == 0)
offset = ss->x;
if(id == 1)
offset = ss->y;
}
if(js && index == 0) {
if(id == 0)
offset = js->player1.x;
if(id == 1)
offset = js->player1.y;
}
if(js && js->chained && index == 1) {
if(id == 0)
offset = js->player2.x;
if(id == 1)
offset = js->player2.y;
}
}
return cb_get_input(port ? 2 : 1, index, id) - offset;
}
} my_interface_obj;
void bsnes_interface::videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan)
{
last_hires = hires;
last_interlace = interlace;
if(stepping_into_save) {
(message_output() << "Got video refresh in runtosave, expect desyncs!" << std::endl).end();
}
video_refresh_done = true;
uint32_t fps_n, fps_d;
fps_n = SNES::system.cpu_frequency();
fps_d = interlace ? DURATION_NTSC_FIELD : DURATION_NTSC_FRAME;
lsnes_core_framebuffer_info inf;
inf.type = LSNES_CORE_PIXFMT_LRGB;
inf.mem = const_cast<char*>(reinterpret_cast<const char*>(data));
inf.physwidth = 512;
inf.physheight = 512;
inf.physstride = 2048;
inf.width = hires ? 512 : (gb_raw_signal_enabled ? 416 : 256);
inf.height = 224 * (interlace ? 2 : 1);
inf.stride = interlace ? 2048 : 4096;
inf.offset_x = 0;
inf.offset_y = (overscan ? 16 : 9) * 2;
if(gb_raw_signal_enabled && !hires) {
uint32_t* tmp = tmpalloc_array<uint32_t>(TMP_VIDEO, 512 * 512);
memcpy(tmp, inf.mem, 512 * 512 * sizeof(uint32_t));
inf.mem = (const char*)tmp;
for(uint32_t y = 0; y < 144; y++) {
memcpy(tmp + (inf.offset_y + y) * (inf.stride / sizeof(uint32_t)) + (inf.offset_x + 256),
gb_raw_signal + 160 * y, 160 * sizeof(uint32_t));
for(uint32_t x = 0; x < 160; x++)
gb_raw_signal[160 * y + x] &= 0x7801F;
}
}
cb_submit_frame(&inf, fps_n, fps_d);
if(soundbuf_fill > 0) {
auto freq = SNES::system.apu_frequency();
cb_submit_sound(soundbuf, soundbuf_fill / 2, true, freq / 768.0);
soundbuf_fill = 0;
}
}
class myinput : public gambatte::InputGetter
{
public:
unsigned operator()()
{
//Input is read elsewhere.
return 0;
};
} getinput;
uint8_t read_gb_inputs(bool p14, bool p15)
{
uint8_t u = 0xF;
unsigned v = 0;
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Right) ? 0x10 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Left) ? 0x20 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Up) ? 0x40 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Down) ? 0x80 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::A) ? 0x01 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::B) ? 0x02 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Select) ? 0x04 : 0);
v |= (bsnes_if->inputPoll((unsigned)GameBoy::Input::Start) ? 0x08 : 0);
if(p14 && p15) u -= mlt_req;
if(!p14) u &= ((v >> 4) ^ 15);
if(!p15) u &= ((v & 15) ^ 15);
if(p14) u |= 0x10;
if(p15) u |= 0x20;
return u;
}
gambatte::extra_callbacks gambatte_sgb_hooks = {
.context = NULL,
.read_p1_high = [](void* context) -> uint8_t {
return 0xF - mlt_req;
},
.write_p1 = [](void* context, uint8_t value) -> void {
bool p14 = (value & 0x10);
bool p15 = (value & 0x20);
bsnes_if->joypWrite(p15, p14);
p1_value = value;
//If either line is low, mark poll to occur on next read.
pending_poll = (!p14 || !p15);
},
.lcd_scan = [](void* context, uint8_t y, const uint32_t* data)
{
current_ly = y;
if(y < 144) {
for(size_t i = 0; i < 160; i++)
current_scanline[i] = data[i];
if(gb_raw_signal_enabled) {
for(size_t i = 0; i < 160; i++)
gb_raw_signal[160 * y + i] = 0x78000 + ((~data[i]) & 3) * 0x294A;
}
bsnes_if->lcdScanline();
}
},
.read_p1 = [](void* context, uint8_t& v) -> bool
{
bool p14 = (p1_value & 0x10);
bool p15 = (p1_value & 0x20);
v = read_gb_inputs(p14, p15);
//If there is pending poll, do the actual poll.
if(pending_poll) pflag = true;
return true;
},
.ppu_update_timeslice = true
};
// FDIV Soundrate
// 8 21477272/512
// 10 21477272/640
// 14 21477272/896
// 18 21477272/1152
//
SNES::gameboy_interface gambatte_gb_if = {
.do_init = [](GameBoy::Interface* interface) -> void {
//Record the interface and reset the system.
bsnes_if = interface;
gb_instance->reset();
},
.get_ly = []() -> unsigned {
return current_ly;
},
.get_cur_scanline = []() -> uint16_t* {
return current_scanline;
},
.set_mlt_req = [](uint8_t req) -> void {
mlt_req = req;
},
.serialize = [](nall::serializer& s) -> void {
//This can't be done right, do it outside bsnes. Nothing to do here.
},
.runtosave = []() -> void {
//Nothing to do.
},
.run_timeslice = [](SNES::Coprocessor* proc) -> void {
//Dummy framebuffer.
uint32_t dummy_fb[160 * 144];
int64_t slice;
uint32_t* abuffer = NULL;
unsigned _slice;
uint16_t old_ip, new_ip;
//Calculate number of SNES master clock ticks to run.
again:
slice = -proc->clock / SNES::cpu.frequency;
//Correct for frequency divider (FIXME: this doesn't correct for divier changes).
//Also always run one cycle too long. Otherwise scheduler will lock up.
slice = slice / SNES::icd2.fdiv + 1;
if(slice <= 0)
return; //No time to run.
//Now slice is number of GB clocks to run.
if(last_fdiv != SNES::icd2.fdiv) {
last_fdiv = SNES::icd2.fdiv;
SNES::audio.coprocessor_frequency((float)SNES::cpu.frequency / last_fdiv);
}
_slice = slice;
abuffer = tmpalloc_array<uint32_t>(TMP_AUDIO, slice + 2064);
old_ip = gb_instance->get_cpureg(gambatte::GB::REG_PC);
gb_instance->runFor(dummy_fb, 160, abuffer, _slice);
new_ip = gb_instance->get_cpureg(gambatte::GB::REG_PC);
for(unsigned i = 0; i < _slice; i++) {
int16_t l, r;
l = abuffer[i];
r = abuffer[i] >> 16;
SNES::audio.coprocessor_sample(l, r);
}
gb_tsc += _slice;
proc->step(_slice * last_fdiv);
goto again;
},
.cartridge_sha256 = []() -> nall::string {
return sha256(&gb_romdata[0], gb_romdata.size());
},
.default_rates = false,
};
unsigned index_to_bsnes_type[] = {
SNES_DEVICE_NONE, SNES_DEVICE_JOYPAD, SNES_DEVICE_JOYPAD, SNES_DEVICE_MULTITAP, SNES_DEVICE_MULTITAP,
SNES_DEVICE_MOUSE, SNES_DEVICE_JUSTIFIER, SNES_DEVICE_JUSTIFIERS, SNES_DEVICE_SUPER_SCOPE,
SNES_DEVICE_JOYPAD
};
std::string get_cartridge_name()
{
std::ostringstream name;
if(gb_romdata.size() < 0x200)
return ""; //Bad.
for(unsigned i = 0; i < 16; i++) {
unsigned char ch = gb_romdata[0x134 + i];
if(ch) {
if(ch >= 32 && ch <= 126)
name << (char)ch;
else
name << hexch[ch >> 4] << hexch[ch & 15];
} else
break;
}
return name.str();
}
time_t walltime_fn()
{
if(rtc_fixed)
return rtc_fixed_val;
if(cb_get_time)
return cb_get_time();
else
return time(0);
}
const char* load_rom(unsigned ctype, lsnes_core_load_rom_image* images, lsnes_core_system_setting* settings,
uint64_t secs, uint64_t subsecs)
{
settings_decoded ds(settings);
snes_term();
snes_unload_cartridge();
SNES::config.random = (ds.irandom != 0);
save_every_frame = (ds.esave != 0);
SNES::config.expansion_port = SNES::System::ExpansionPortDevice::None;
SNES::config.cpu.alt_poll_timings = true;
//Reset Gambatte really.
gb_instance->~GB();
memset(gb_instance, 0, sizeof(gambatte::GB));
new(gb_instance) gambatte::GB;
gb_instance->setInputGetter(&getinput);
gb_instance->set_walltime_fn(walltime_fn);
gb_instance->setExtraCallbacks(&gambatte_sgb_hooks);
rtc_fixed = true;
rtc_fixed_val = secs;
//Flags is always 0.
if(gb_instance->load((const unsigned char*)images[1].data, images[1].size, 0,
GameBoy::System::BootROM::sgb, sizeof(GameBoy::System::BootROM::sgb)) < 0)
return "Error loading ROM";
size_t sramsize = gb_instance->getSaveRam().second;
size_t romsize = images[1].size;
if(reallocate_debug || gb_cur_ramsize != sramsize || gb_cur_romsize != romsize) {
if(debugbuf.cart) delete[] debugbuf.cart;
if(debugbuf.sram) delete[] debugbuf.sram;
debugbuf.cart = NULL;
debugbuf.sram = NULL;
if(sramsize) debugbuf.sram = new uint8_t[(sramsize + 4095) >> 12 << 12];
if(romsize) debugbuf.cart = new uint8_t[(romsize + 4095) >> 12 << 12];
if(sramsize) memset(debugbuf.sram, 0, (sramsize + 4095) >> 12 << 12);
if(romsize) memset(debugbuf.cart, 0, (romsize + 4095) >> 12 << 12);
memset(debugbuf.wram, 0, 32768);
memset(debugbuf.ioamhram, 0, 512);
debugbuf.wramcheat.clear();
debugbuf.sramcheat.clear();
debugbuf.cartcheat.clear();
debugbuf.trace_cpu = false;
reallocate_debug = false;
gb_cur_ramsize = sramsize;
gb_cur_romsize = romsize;
}
gb_instance->set_debug_buffer(debugbuf);
gb_instance->set_emuflags(1); //Crash on SIGILL.
rtc_fixed = false;
gb_romdata.resize(images[1].size);
memcpy(&gb_romdata[0], images[1].data, images[1].size);
//Setup palette (it is fixed for SGB).
for(unsigned i = 0; i < 12; i++)
gb_instance->setDmgPaletteColor(i >> 2, i & 3, i & 3);
SNES::gb_override_flag = true;
SNES::gb_if = &gambatte_gb_if;
//Because we pass the GB ROM to bsnes, its checksum will be correct even with default loadif.
bool r = snes_load_cartridge_super_game_boy(images[0].markup, (unsigned char*)images[0].data, images[0].size,
images[1].markup, (unsigned char*)images[1].data, images[1].size);
if(r) {
last_fdiv = SNES::icd2.fdiv;
internal_rom = ctype;
snes_set_controller_port_device(false, index_to_bsnes_type[ds.type1]);
snes_set_controller_port_device(true, index_to_bsnes_type[ds.type2]);
port_is_ycable[0] = (ds.type1 == 9);
port_is_ycable[1] = (ds.type2 == 9);
have_saved_this_frame = false;
do_reset_flag = -1;
current_ly = 0;
mlt_req = 0;
sgb_button_state = 0;
p1_value = 0;
memset(current_scanline, 0, 320);
pending_poll = false;
pflag = false;
gb_tsc = 0;
cb_notify_action_update();
}
return r ? NULL : "Error loading ROM";
}
void bsnes_call_power_or_reset(bool hard)
{
if(hard) {
SNES::gb_override_flag = true;
SNES::system.power();
//Poweron initializes this.
last_fdiv = SNES::icd2.fdiv;
} else
SNES::system.reset();
}
const char* interface(lsnes_core_enumerate_cores& arg)
{
if(getenv("GB_SHOW_DEBUG_SCREEN"))
gb_raw_signal_enabled = true;
static bool basic_init_done = false;
if(!basic_init_done) {
SNES::bus.debug_read = bsnes_debug_read;
SNES::bus.debug_write = bsnes_debug_write;
old = SNES::interface;
SNES::interface = &my_interface_obj;
SNES::system.init();
gb_instance = new gambatte::GB;
gb_instance->setInputGetter(&getinput);
gb_instance->set_walltime_fn(walltime_fn);
uint8_t* tmp = new uint8_t[98816];
memset(tmp, 0, 98816);
debugbuf.wram = tmp;
debugbuf.bus = tmp + 32768;
debugbuf.ioamhram = tmp + 98304;
debugbuf.read = gambatte_debug_read;
debugbuf.write = gambatte_debug_write;
debugbuf.trace = gambatte_debug_trace;
debugbuf.trace_cpu = false;
debugbuf.cart = NULL;
debugbuf.sram = NULL;
gb_instance->set_debug_buffer(debugbuf);
}
arg.sysregions = sysregions_supported;
record_callbacks(arg);
gb_add_disasms();
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_core_info& arg)
{
arg.json = bsnes_gambatte_controller_json;
arg.root_ptr = "ports";
arg.shortname = "bsnes-gambatte";
arg.fullname = "bsnes v085 / Gambatte r537";
core_bsnes_gambatte_name = arg.fullname;
arg.cap_flags1 = LSNES_CORE_CAP1_MULTIREGION | LSNES_CORE_CAP1_PFLAG | LSNES_CORE_CAP1_ACTION |
LSNES_CORE_CAP1_BUSMAP | LSNES_CORE_CAP1_SRAM | LSNES_CORE_CAP1_RESET |
LSNES_CORE_CAP1_SCALE | LSNES_CORE_CAP1_RUNTOSAVE | LSNES_CORE_CAP1_POWERON |
LSNES_CORE_CAP1_UNLOAD | LSNES_CORE_CAP1_DEBUG | LSNES_CORE_CAP1_TRACE |
LSNES_CORE_CAP1_CHEAT | LSNES_CORE_CAP1_COVER | LSNES_CORE_CAP1_PREEMULATE |
LSNES_CORE_CAP1_REGISTERS | LSNES_CORE_CAP1_MEMWATCH | LSNES_CORE_CAP1_LIGHTGUN;
arg.actions = actions_list;
arg.trace_cpu_list = trace_cpu_list;
return RET_OK;
}
const char* type_supergameboy(lsnes_core_get_type_info& arg)
{
arg.core = def_core_bsnes_gambatte;
arg.iname = "sgb";
arg.hname = "Super Game Boy";
arg.sysname = "SGB";
arg.bios = "sgb.sfc";
arg.regions = regions_sgb;
arg.images = sgb_images;
arg.settings = bsnes_gambatte_settings;
return RET_OK;
}
const char* region_ntsc(lsnes_core_get_region_info& arg)
{
arg.iname = "ntsc";
arg.hname = "NTSC";
arg.priority = 0;
arg.multi = 0;
//Apparently the fps is wrong way around.
arg.fps_d = 10738636;
arg.fps_n = 178683;
arg.compatible_runs = compat_regions_ntsc;
return RET_OK;
}
const char* sysregion_sgb_ntsc(lsnes_core_get_sysregion_info& arg)
{
arg.name = "gambatte_sgb_ntsc";
arg.type = def_type_supergameboy;
arg.region = def_region_ntsc;
arg.for_system = "SGB";
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_av_state& arg)
{
if(internal_rom < 0) {
arg.fps_n = 60;
arg.fps_d = 1;
arg.par = 1.0;
arg.rate_n = 64081;
arg.rate_d = 2;
} else {
arg.fps_n = SNES::system.cpu_frequency();
arg.fps_d = last_interlace ? DURATION_NTSC_FIELD : DURATION_NTSC_FRAME;
arg.par = 1.146;
arg.rate_n = SNES::system.apu_frequency();
arg.rate_d = static_cast<uint32_t>(768);
}
arg.lightgun_width = 256;
arg.lightgun_height = 224;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_emulate& arg)
{
if(internal_rom < 0)
return RET_OK;
bool was_delay_reset = false;
int16_t reset = cb_get_input(0, 0, 1);
int16_t hreset = 0;
hreset = cb_get_input(0, 0, 4);
if(reset) {
long hi = cb_get_input(0, 0, 2);
long lo = cb_get_input(0, 0, 3);
long delay = 10000 * hi + lo;
if(delay > 0) {
was_delay_reset = true;
(message_output() << "Executing delayed reset... This can take some time!"
<< std::endl).end();
video_refresh_done = false;
delayreset_cycles_run = 0;
delayreset_cycles_target = delay;
forced_hook = true;
SNES::cpu.step_event = bsnes_delayreset_fn;
again:
SNES::system.run();
if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent
&& SNES::debugger.break_event == SNES::Debugger::BreakEvent::BreakpointHit) {
goto again;
}
SNES::cpu.step_event = nall::function<bool()>();
forced_hook = false;
bsnes_update_trace_hook_state();
if(video_refresh_done) {
//Force the reset here.
(message_output() << "SNES reset (forced at " << delayreset_cycles_run << ")"
<< std::endl).end();
bsnes_call_power_or_reset(hreset);
goto out;
}
bsnes_call_power_or_reset(hreset);
(message_output() << "SNES reset (delayed " << delayreset_cycles_run << ")"
<< std::endl).end();
} else if(delay == 0) {
bsnes_call_power_or_reset(hreset);
(message_output() << "SNES reset" << std::endl).end();
}
}
out:
do_reset_flag = -1;
if(!have_saved_this_frame && save_every_frame && !was_delay_reset)
SNES::system.runtosave();
if(trace_cpu_enable)
SNES::cpu.step_event = bsnes_trace_fn;
again2:
SNES::system.run();
if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent &&
SNES::debugger.break_event == SNES::Debugger::BreakEvent::BreakpointHit) {
goto again2;
}
SNES::cpu.step_event = nall::function<bool()>();
have_saved_this_frame = false;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_savestate& arg)
{
if(internal_rom < 0)
return "No ROM loaded";
//Grab gambatte state.
std::vector<char> gb_state;
gb_instance->saveState(gb_state);
//A few other variables that need saving.
std::vector<char> oth_state;
oth_state.resize(340);
write_val32(&oth_state[0], current_ly);
write_val8(&oth_state[4], mlt_req);
write_val8(&oth_state[5], sgb_button_state);
write_val8(&oth_state[6], last_fdiv);
write_val8(&oth_state[7], p1_value);
write_val16a(&oth_state[8], current_scanline, 160);
write_val8(&oth_state[328], (pending_poll ? 1 : 0) | (pflag ? 2 : 0));
write_val32(&oth_state[332], gb_tsc >> 32);
write_val32(&oth_state[336], gb_tsc);
//Grab BSNES state.
serializer snes_state = SNES::system.serialize();
//Put the states all together.
char* tmp;
arg.size = 12 + gb_state.size() + oth_state.size() + snes_state.size();
arg.data = tmp = tmpalloc_array<char>(TMP_UNSPEC, arg.size);
write_val32(tmp + 0, gb_state.size());
write_val32(tmp + 4, oth_state.size());
write_val32(tmp + 8, snes_state.size());
size_t ptr = 12;
memcpy(tmp + ptr, &gb_state[0], gb_state.size());
ptr += gb_state.size();
memcpy(tmp + ptr, &oth_state[0], oth_state.size());
ptr += oth_state.size();
memcpy(tmp + ptr, snes_state.data(), snes_state.size());
ptr += snes_state.size();
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_loadstate& arg)
{
if(internal_rom < 0)
return "No ROM loaded";
unsigned gb_size, oth_size, snes_size;
if(arg.size < 12)
return "Bad savestate, too small";
read_val32(arg.data + 0, gb_size);
read_val32(arg.data + 4, oth_size);
read_val32(arg.data + 8, snes_size);
if(arg.size < (uint64_t)12 + gb_size + oth_size + snes_size)
return "Bad savestate, truncated";
if(oth_size != 340)
return "Bad savestate, expected 340 bytes of other data";
//Other state.
const char* oth_base = (const char*)arg.data + 12 + gb_size;
std::vector<char> oth_s(oth_base, oth_base + oth_size);
read_val32(&oth_s[0], current_ly);
read_val8(&oth_s[4], mlt_req);
read_val8(&oth_s[5], sgb_button_state);
read_val8(&oth_s[6], last_fdiv);
read_val8(&oth_s[7], p1_value);
read_val16a(&oth_s[8], current_scanline, 160);
uint8_t tmp;
uint32_t tsc_l, tsc_h;
read_val8(&oth_s[328], tmp);
read_val32(&oth_s[332], tsc_h);
read_val32(&oth_s[336], tsc_l);
//SNES state.
serializer snes_s(reinterpret_cast<const uint8_t*>(arg.data + 12 + gb_size + oth_size), snes_size);
SNES::gb_override_flag = true; //Unserialize calls power.
if(!SNES::system.unserialize(snes_s))
return "SGB core rejected savestate";
//Due to what SNES does, restore GB state after SNES state.
const char* gb_base = (const char*)arg.data + 12;
std::vector<char> gb_s(gb_base, gb_base + gb_size);
gb_instance->loadState(gb_s);
pending_poll = (tmp & 1);
pflag = (tmp & 2);
gb_tsc = ((uint64_t)tsc_h << 32) + tsc_l;
have_saved_this_frame = true;
do_reset_flag = -1;
return RET_OK;
}
const char* type_supergameboy(lsnes_core_get_controllerconfig& arg)
{
settings_decoded ds(arg.settings);
static unsigned ports[4];
static lsnes_core_get_controllerconfig_logical_entry lcid[9];
ports[0] = 11;
ports[1] = ds.type1;
ports[2] = ds.type2;
ports[3] = LSNES_END_LIST;
arg.controller_types = ports;
arg.logical_map = lcid;
unsigned p1controllers = controller_count[ds.type1];
unsigned p2controllers = controller_count[ds.type2];
if(p1controllers == 4) {
arg.logical_map[0] = mklcid(1, 0);
for(size_t j = 0; j < p2controllers; j++)
arg.logical_map[j + 1] = mklcid(2U, j);
for(size_t j = 1; j < p1controllers; j++)
arg.logical_map[j + p2controllers] = mklcid(1U, j);
} else {
for(size_t j = 0; j < p1controllers; j++)
arg.logical_map[j] = mklcid(1, j);
for(size_t j = 0; j < p2controllers; j++)
arg.logical_map[j + p1controllers] = mklcid(2U, j);
}
arg.logical_map[p1controllers + p2controllers] = mklcid(0U, 0U);
return RET_OK;
}
const char* type_supergameboy(lsnes_core_load_rom& arg)
{
return load_rom(def_type_supergameboy, arg.images, arg.settings, arg.rtc_sec, arg.rtc_subsec);
}
const char* core_bsnes_gambatte(lsnes_core_get_region& arg)
{
arg.region = def_region_ntsc;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_set_region& arg)
{
switch(arg.region) {
case def_region_ntsc:
return RET_OK;
default:
return complain_unknown_region(arg.region);
}
}
const char* interface(lsnes_core_deinitialize& arg)
{
delete gb_instance;
delete[] debugbuf.wram;
delete[] debugbuf.cart;
delete[] debugbuf.sram;
debugbuf.wramcheat.clear();
debugbuf.sramcheat.clear();
debugbuf.cartcheat.clear();
SNES::interface = old;
gb_remove_disasms();
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_pflag& arg)
{
arg.pflag = pflag ? 1 : 0;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_set_pflag& arg)
{
pflag = arg.pflag;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_action_flags& arg)
{
if(arg.action >= 0 && arg.action <= 3)
arg.flags = 1;
else if(arg.action >= 4 && arg.action <= 23) {
unsigned y = (arg.action - 4) / 4;
arg.flags = SNES::ppu.layer_enabled[y][arg.action % 4] ? 3 : 1;
} else
arg.flags = 0;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_execute_action& arg)
{
switch(arg.action) {
case 0: //Soft reset.
do_reset_flag = 0;
do_hreset_flag = false;
break;
case 1: //Hard reset.
do_reset_flag = 0;
do_hreset_flag = true;
break;
case 2: //Delayed soft reset.
do_reset_flag = arg.params[0].integer;
do_hreset_flag = false;
break;
case 3: //Delayed hard reset.
do_reset_flag = arg.params[0].integer;
do_hreset_flag = true;
break;
}
if(arg.action >= 4 && arg.action <= 23) {
unsigned y = (arg.action - 4) / 4;
SNES::ppu.layer_enabled[y][arg.action % 4] = !SNES::ppu.layer_enabled[y][arg.action % 4];
cb_notify_action_update();
}
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_bus_mapping& arg)
{
arg.base = MAP_BASE_SNES_BUS;
arg.size = 0x1010000;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_enumerate_sram& arg)
{
std::set<std::string> set;
if(internal_rom >= 0) {
for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
SNES::Cartridge::NonVolatileRAM& s = SNES::cartridge.nvram[i];
set.insert(sram_name(s.id, s.slot));
}
auto g = gb_instance->getSaveRam();
if(g.second)
set.insert("gbsram");
set.insert("gbrtc");
}
arg.srams = tmpalloc_array<const char*>(TMP_UNSPEC, set.size() + 1);
unsigned key = TMP_UNSPEC + 1;
for(auto& i : set) {
arg.srams[key - TMP_UNSPEC - 1] = tmpalloc_str(key, i);
key++;
}
arg.srams[key - TMP_UNSPEC - 1] = NULL;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_save_sram& arg)
{
std::vector<std::pair<const char*, std::pair<const char*, size_t>>> out;
unsigned key = TMP_UNSPEC + 1;
if(internal_rom < 0)
goto out;
for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
//SNES SRAMs
SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[i];
add_sram_entry(out, key, sram_name(r.id, r.slot), r.data, r.size);
}
{
//GB SRAMs
auto g = gb_instance->getSaveRam();
char gbrtc[8];
time_t timebase = gb_instance->getRtcBase();
for(size_t i = 0; i < sizeof(gbrtc); i++)
gbrtc[i] = ((unsigned long long)timebase >> (8 * i));
if(g.second)
add_sram_entry(out, key, "gbsram", g.first, g.second);
add_sram_entry(out, key, "gbrtc", gbrtc, sizeof(gbrtc));
}
out:
//Copy srams to output.
arg.srams = tmpalloc_array<lsnes_core_sram>(TMP_UNSPEC, out.size() + 1);
unsigned k = 0;
for(auto& i : out) {
arg.srams[k].name = i.first;
arg.srams[k].data = i.second.first;
arg.srams[k].size = i.second.second;
k++;
}
arg.srams[k].name = NULL;
arg.srams[k].data = NULL;
arg.srams[k].size = 0;
return 0;
}
const char* core_bsnes_gambatte(lsnes_core_load_sram& arg)
{
std::set<std::string> used;
if(internal_rom < 0) {
//If no ROM, warn about everything.
for(lsnes_core_sram* i = arg.srams; i->name; i++) {
(message_output() << "WARNING: SRAM '" << i->name << "': Not found on cartridge."
<< std::endl).end();
}
return RET_OK;
}
//Check for no SRAM.
if(!arg.srams->name)
return RET_OK;
for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
SNES::Cartridge::NonVolatileRAM& _r = SNES::cartridge.nvram[i];
handle_sram_load(arg, sram_name(_r.id, _r.slot), _r.data, _r.size, used);
}
auto g = gb_instance->getSaveRam();
unsigned char gbrtc[8];
if(g.second)
handle_sram_load(arg, "gbsram", g.first, g.second, used);
handle_sram_load(arg, "gbrtc", gbrtc, sizeof(gbrtc), used);
//Unpack gbrtc.
time_t timebase = 0;
for(size_t i = 0; i < sizeof(gbrtc); i++)
timebase |= (unsigned long long)gbrtc[i] << (8 * i);
gb_instance->setRtcBase(timebase);
//Warn about unused SRAMs.
for(lsnes_core_sram* i = arg.srams; i->name; i++) {
if(!used.count(i->name)) {
(message_output() << "WARNING: SRAM '" << i->name << "': Not found on cartridge."
<< std::endl).end();
}
}
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_reset_action& arg)
{
arg.hardreset = 1;
arg.softreset = 0;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_compute_scale& arg)
{
arg.hfactor = (arg.width < 400 || arg.width == 416) ? 2 : 1;
arg.vfactor = (arg.height < 400) ? 2 : 1;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_runtosave& arg)
{
if(internal_rom < 0)
return RET_OK;
stepping_into_save = true;
SNES::system.runtosave();
have_saved_this_frame = true;
stepping_into_save = false;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_poweron& arg)
{
if(internal_rom < 0)
return RET_OK;
bsnes_call_power_or_reset(true);
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_unload_cartridge& arg)
{
if(internal_rom < 0)
return RET_OK;
delete[] debugbuf.cart;
delete[] debugbuf.sram;
debugbuf.cart = NULL;
debugbuf.sram = NULL;
gb_cur_ramsize = 0;
gb_cur_romsize = 0;
debugbuf.wramcheat.clear();
debugbuf.sramcheat.clear();
debugbuf.cartcheat.clear();
snes_term();
snes_unload_cartridge();
internal_rom = -1;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_debug_reset& arg)
{
//Next load will reset gambatte trace buffers.
reallocate_debug = true;
SNES::bus.clearDebugFlags();
SNES::cheat.reset();
trace_cpu_enable = false;
trace_smp_enable = false;
bsnes_update_trace_hook_state();
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_set_debug_flags& arg)
{
unsigned sflags = arg.set;
unsigned cflags = arg.clear;
uint64_t addr = arg.addr;
switch(addr) {
case 0:
//S-CPU.
if(sflags & 8) trace_cpu_enable = true;
if(cflags & 8) trace_cpu_enable = false;
bsnes_update_trace_hook_state();
break;
case 1:
//S-SMP.
if(sflags & 8) trace_smp_enable = true;
if(cflags & 8) trace_smp_enable = false;
bsnes_update_trace_hook_state();
break;
case 2:
//GB CPU.
if(sflags & 8) debugbuf.trace_cpu = true;
if(cflags & 8) debugbuf.trace_cpu = false;
break;
}
auto _addr = recognize_address(addr);
switch(classify_address_kind(_addr.first)) {
case ADDR_CLASS_ALL:
SNES::bus.debugFlags(sflags & 7, cflags & 7);
//Set/Clear every known GB debug.
gambatte_set_debugbuf_all(debugbuf.wram, 32768, sflags, cflags);
gambatte_set_debugbuf_all(debugbuf.bus, 65536, sflags, cflags);
gambatte_set_debugbuf_all(debugbuf.ioamhram, 512, sflags, cflags);
gambatte_set_debugbuf_all(debugbuf.sram, gb_instance->getSaveRam().second, sflags, cflags);
gambatte_set_debugbuf_all(debugbuf.cart, gb_romdata.size(), sflags, cflags);
break;
case ADDR_CLASS_GB:
if((sflags | cflags) & 7) {
switch(_addr.first) {
case MAP_KIND_GB_BUS:
gambatte_set_debugbuf(debugbuf.bus, _addr.second, 65536, sflags, cflags);
break;
case MAP_KIND_GB_HRAM:
gambatte_set_debugbuf(debugbuf.ioamhram, _addr.second, 512, sflags, cflags);
break;
case MAP_KIND_GB_ROM:
gambatte_set_debugbuf(debugbuf.cart, _addr.second, gb_romdata.size(), sflags, cflags);
break;
case MAP_KIND_GB_SRAM:
gambatte_set_debugbuf(debugbuf.sram, _addr.second, gb_instance->getSaveRam().second,
sflags, cflags);
break;
case MAP_KIND_GB_WRAM:
gambatte_set_debugbuf(debugbuf.wram, _addr.second, 32768, sflags, cflags);
break;
}
}
break;
case ADDR_CLASS_SNES:
if((sflags | cflags) & 7) {
SNES::bus.debugFlags(sflags & 7, cflags & 7, _addr.first, _addr.second);
}
break;
//Can't be placed on NONE.
}
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_set_cheat& arg)
{
uint64_t addr = arg.addr;
uint64_t value = arg.value;
bool set = arg.set;
bool s = false;
auto _addr = recognize_address(addr);
switch(classify_address_kind(_addr.first)) {
//Can't be placed on ALL nor NONE.
case ADDR_CLASS_GB:
switch(_addr.first) {
case MAP_KIND_GB_WRAM:
gambatte_set_cheat(debugbuf.wram, debugbuf.wramcheat, _addr.second, 32768, set, value);
break;
case MAP_KIND_GB_SRAM:
gambatte_set_cheat(debugbuf.sram, debugbuf.sramcheat, _addr.second,
gb_instance->getSaveRam().second, set, value);
break;
case MAP_KIND_GB_ROM:
gambatte_set_cheat(debugbuf.cart, debugbuf.cartcheat, _addr.second, gb_romdata.size(), set,
value);
break;
}
break;
case ADDR_CLASS_SNES: {
unsigned x = 0;
while(x < 0x1000000) {
x = SNES::bus.enumerateMirrors(_addr.first, _addr.second, x);
if(x < 0x1000000) {
if(set) {
for(size_t i = 0; i < SNES::cheat.size(); i++) {
if(SNES::cheat[i].addr == x) {
SNES::cheat[i].data = value;
s = true;
break;
}
}
if(!s) SNES::cheat.append({x, (uint8_t)value, true});
} else
for(size_t i = 0; i < SNES::cheat.size(); i++) {
if(SNES::cheat[i].addr == x) {
SNES::cheat.remove(i);
break;
}
}
}
x++;
}
SNES::cheat.synchronize();
}
}
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_draw_cover& arg)
{
lsnes_core_framebuffer_info* fbinfo = tmpalloc<lsnes_core_framebuffer_info>(TMP_UNSPEC);
uint32_t* fbmem = tmpalloc_array<uint32_t>(TMP_UNSPEC + 1, 512 * 448);
fbinfo->type = LSNES_CORE_PIXFMT_LRGB;
fbinfo->mem = (const char*)fbmem;
fbinfo->physwidth = 512;
fbinfo->physheight = 448;
fbinfo->physstride = 2048;
fbinfo->width = 512;
fbinfo->height = 448;
fbinfo->stride = 2048;
fbinfo->offset_x = 0;
fbinfo->offset_y = 0;
if(cb_render_text) {
lsnes_core_fontrender_req req = {
.cb_ctx = NULL,
.alloc = [](void*, size_t mem) -> void* { return tmpalloc_array<char*>(TMP_TXTBMP, mem); },
.text = NULL,
.text_len = -1,
.bytes_pp = 4,
.fg_color = 0x783E0, //Green.
.bg_color = 0x00000, //Black.
.bitmap = NULL,
.width = 0,
.height = 0
};
req.text = tmp_sprintf(TMP_TEXT, "Core: %s\nGame: %s\n", core_bsnes_gambatte_name.c_str(),
get_cartridge_name().c_str());
cb_render_text(&req);
//Blit the bitmap on screen.
uint32_t* dbuf = (uint32_t*)req.bitmap;
size_t cwidth = (req.width < 512) ? req.width : 512;
for(unsigned y = 0; y < 448; y++) {
for(unsigned x = 0; x < 512; x++)
fbmem[y * 512 + x] = req.bg_color;
if(y < req.height)
memcpy(fbmem + y * 512, dbuf + y * req.width, sizeof(uint32_t) * cwidth);
}
} else {
for(unsigned y = 0; y < 448; y++)
for(unsigned x = 0; x < 512; x++) {
unsigned _x = (x >> 3) & 1;
unsigned _y = (y >> 3) & 1;
fbmem[y * 512 + x] = (_x ^ _y) ? 0x7FC00 : 0x7801F;
}
}
arg.coverpage = fbinfo;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_pre_emulate& arg)
{
arg.set_input(arg.context, 0, 0, 1, (do_reset_flag >= 0) ? 1 : 0);
arg.set_input(arg.context, 0, 0, 4, do_hreset_flag ? 1 : 0);
if(do_reset_flag >= 0) {
arg.set_input(arg.context, 0, 0, 2, do_reset_flag / 10000);
arg.set_input(arg.context, 0, 0, 3, do_reset_flag % 10000);
} else {
arg.set_input(arg.context, 0, 0, 2, 0);
arg.set_input(arg.context, 0, 0, 3, 0);
}
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_device_regs& arg)
{
arg.regs = snes_gb_registers;
return RET_OK;
}
const char* core_bsnes_gambatte(lsnes_core_get_vma_list& arg)
{
static lsnes_core_get_vma_list_vma* tmpmem[32];
unsigned key = 0;
if(internal_rom >= 0) {
tmpmem[key++] = &vma_WRAM;
tmpmem[key++] = &vma_APURAM;
tmpmem[key++] = &vma_VRAM;
tmpmem[key++] = &vma_OAM;
tmpmem[key++] = &vma_CGRAM;
tmpmem[key++] = fixup_vma(vma_SRAM, SNES::cartridge.ram.data(), SNES::cartridge.ram.size());
tmpmem[key++] = fixup_vma(vma_ROM, SNES::cartridge.rom.data(), SNES::cartridge.rom.size());
tmpmem[key++] = &vma_BUS;
tmpmem[key++] = fixup_vma(vma_GBROM, &gb_romdata[0], gb_romdata.size());
tmpmem[key++] = fixup_vma(vma_GBSRAM, gb_instance->getSaveRam());
tmpmem[key++] = fixup_vma(vma_GBWRAM, gb_instance->getWorkRam());
tmpmem[key++] = fixup_vma(vma_GBHRAM, gb_instance->getIoRam());
tmpmem[key++] = fixup_vma(vma_GBVRAM, gb_instance->getVideoRam());
tmpmem[key++] = &vma_GBBUS;
}
tmpmem[key] = NULL;
arg.vmas = tmpmem;
return RET_OK;
}
}
int lsnes_core_entrypoint(unsigned action, unsigned item, void* params, const char** error)
{
try {
const char* ret;
switch(action) {
CASE_CALL_NOITEM(LSNES_CORE_ENUMERATE_CORES);
CASE_CALL_CORE(LSNES_CORE_GET_CORE_INFO);
CASE_CALL_TYPE(LSNES_CORE_GET_TYPE_INFO);
CASE_CALL_REGION(LSNES_CORE_GET_REGION_INFO);
CASE_CALL_SYSREGION(LSNES_CORE_GET_SYSREGION_INFO);
CASE_CALL_CORE(LSNES_CORE_GET_AV_STATE);
CASE_CALL_CORE(LSNES_CORE_EMULATE);
CASE_CALL_CORE(LSNES_CORE_SAVESTATE);
CASE_CALL_CORE(LSNES_CORE_LOADSTATE);
CASE_CALL_TYPE(LSNES_CORE_GET_CONTROLLERCONFIG);
CASE_CALL_TYPE(LSNES_CORE_LOAD_ROM);
CASE_CALL_CORE(LSNES_CORE_GET_REGION);
CASE_CALL_CORE(LSNES_CORE_SET_REGION);
CASE_CALL_NOITEM(LSNES_CORE_DEINITIALIZE);
CASE_CALL_CORE(LSNES_CORE_GET_PFLAG);
CASE_CALL_CORE(LSNES_CORE_SET_PFLAG);
CASE_CALL_CORE(LSNES_CORE_GET_ACTION_FLAGS);
CASE_CALL_CORE(LSNES_CORE_EXECUTE_ACTION);
CASE_CALL_CORE(LSNES_CORE_GET_BUS_MAPPING);
CASE_CALL_CORE(LSNES_CORE_ENUMERATE_SRAM);
CASE_CALL_CORE(LSNES_CORE_SAVE_SRAM);
CASE_CALL_CORE(LSNES_CORE_LOAD_SRAM);
CASE_CALL_CORE(LSNES_CORE_GET_RESET_ACTION);
CASE_CALL_CORE(LSNES_CORE_COMPUTE_SCALE);
CASE_CALL_CORE(LSNES_CORE_RUNTOSAVE);
CASE_CALL_CORE(LSNES_CORE_POWERON);
CASE_CALL_CORE(LSNES_CORE_UNLOAD_CARTRIDGE);
CASE_CALL_CORE(LSNES_CORE_DEBUG_RESET);
CASE_CALL_CORE(LSNES_CORE_SET_DEBUG_FLAGS);
CASE_CALL_CORE(LSNES_CORE_SET_CHEAT);
CASE_CALL_CORE(LSNES_CORE_DRAW_COVER);
CASE_CALL_CORE(LSNES_CORE_PRE_EMULATE);
CASE_CALL_CORE(LSNES_CORE_GET_DEVICE_REGS);
CASE_CALL_CORE(LSNES_CORE_GET_VMA_LIST);
default:
ret = tmp_sprintf(TMP_ERROR, "Unsupported request %u", action);
break;
}
*error = ret;
return *error ? -1 : 0;
} catch(std::bad_alloc& e) {
//Don't throw exceptions across module boundary.
*error = "Out of memory";
return -1;
} catch(std::exception& e) {
//Don't throw exceptions across module boundary.
try {
//Really, catch the exception if this fails due to OOM.
*error = tmpalloc_str(TMP_ERROR, std::string("Exception: ") + e.what());
return -1;
} catch(std::bad_alloc& f) {
*error = "Out of memory (while reporting exception)";
return -1;
}
}
}
Reference in a new issue View git blame Copy permalink