ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/submodules/sameboy/BizInterface.c

598 lines
15 KiB
C
Raw Blame History

#include <stdlib.h>
#include <string.h>
#include <gb.h>
#include "blip_buf.h"
#ifdef _WIN32
#define EXPORT __declspec(dllexport)
#else
#define EXPORT __attribute__((visibility("default")))
#endif
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef void (*input_callback_t)(void);
typedef void (*rumble_callback_t)(u32);
typedef void (*trace_callback_t)(u16);
typedef void (*memory_callback_t)(u16);
typedef void (*printer_callback_t)(u32*, u8, u8, u8, u8);
typedef void (*scanline_callback_t)(u32);
typedef struct
{
GB_gameboy_t gb;
blip_t* blip_l;
blip_t* blip_r;
GB_sample_t sampleLatch;
u32 nsamps;
u32 vbuf[256 * 224];
u32 bg_pal[0x20];
u32 obj_pal[0x20];
GB_palette_t custom_pal;
input_callback_t input_cb;
rumble_callback_t rumble_cb;
trace_callback_t trace_cb;
memory_callback_t read_cb;
memory_callback_t write_cb;
memory_callback_t exec_cb;
printer_callback_t printer_cb;
scanline_callback_t scanline_cb;
u32 scanline_sl;
bool vblank_occurred;
bool new_frame_present;
u64 cc;
} biz_t;
static inline u8 PeekIO(biz_t* biz, u8 addr)
{
u8* io = GB_get_direct_access(&biz->gb, GB_DIRECT_ACCESS_IO, NULL, NULL);
return io[addr];
}
static void sample_cb(GB_gameboy_t* gb, GB_sample_t* sample)
{
biz_t* biz = (biz_t*)gb;
if (biz->sampleLatch.left != sample->left)
{
blip_add_delta(biz->blip_l, biz->nsamps, biz->sampleLatch.left - sample->left);
biz->sampleLatch.left = sample->left;
}
if (biz->sampleLatch.right != sample->right)
{
blip_add_delta(biz->blip_r, biz->nsamps, biz->sampleLatch.right - sample->right);
biz->sampleLatch.right = sample->right;
}
biz->nsamps++;
}
static u32 rgb_cb(GB_gameboy_t* gb, u8 r, u8 g, u8 b)
{
return (0xFF << 24) | (r << 16) | (g << 8) | b;
}
static void vblank_cb(GB_gameboy_t* gb, GB_vblank_type_t type)
{
biz_t* biz = (biz_t*)gb;
biz->vblank_occurred = true;
if (type != GB_VBLANK_TYPE_REPEAT)
{
biz->new_frame_present = true;
}
}
static u8 camera_pixel_cb(GB_gameboy_t* gb, u8 x, u8 y)
{
// stub for now (also needed for determinism)
return 0;
}
static void RumbleCallbackRelay(GB_gameboy_t* gb, double rumble_amplitude)
{
((biz_t*)gb)->rumble_cb(INT32_MAX * rumble_amplitude);
}
static u8 ReadCallbackRelay(GB_gameboy_t* gb, u16 addr, u8 data)
{
((biz_t*)gb)->read_cb(addr);
return data;
}
static bool WriteCallbackRelay(GB_gameboy_t* gb, u16 addr, u8 data)
{
((biz_t*)gb)->write_cb(addr);
return true;
}
static void ExecCallbackRelay(GB_gameboy_t* gb, u16 addr, u8 opcode)
{
biz_t* biz = (biz_t*)gb;
if (biz->trace_cb)
{
biz->trace_cb(addr);
}
if (biz->exec_cb)
{
biz->exec_cb(addr);
}
}
static void PrinterCallbackRelay(GB_gameboy_t* gb, u32* image, u8 height, u8 top_margin, u8 bottom_margin, u8 exposure)
{
((biz_t*)gb)->printer_cb(image, height, top_margin, bottom_margin, exposure);
}
static void PrinterDoneCallbackRelay(GB_gameboy_t* gb)
{
// nothing to do
}
static void ScanlineCallbackRelay(GB_gameboy_t* gb, u8 line)
{
biz_t* biz = (biz_t*)gb;
if (line == biz->scanline_sl)
{
biz->scanline_cb(PeekIO(biz, GB_IO_LCDC));
}
}
EXPORT biz_t* sameboy_create(u8* romdata, u32 romlen, u8* biosdata, u32 bioslen, GB_model_t model, bool realtime, bool nobounce)
{
biz_t* biz = calloc(1, sizeof (biz_t));
GB_random_seed(0);
GB_init(&biz->gb, model);
// this will be NULL if a GBS is going to be loaded later
if (romdata)
{
GB_load_rom_from_buffer(&biz->gb, romdata, romlen);
}
GB_load_boot_rom_from_buffer(&biz->gb, biosdata, bioslen);
GB_set_sample_rate(&biz->gb, GB_get_clock_rate(&biz->gb) / 2 / 8);
GB_set_rumble_mode(&biz->gb, GB_RUMBLE_ALL_GAMES);
GB_set_rumble_callback(&biz->gb, RumbleCallbackRelay);
GB_apu_set_sample_callback(&biz->gb, sample_cb);
GB_set_rgb_encode_callback(&biz->gb, rgb_cb);
GB_set_vblank_callback(&biz->gb, vblank_cb);
GB_set_camera_get_pixel_callback(&biz->gb, camera_pixel_cb);
GB_set_pixels_output(&biz->gb, biz->vbuf);
GB_set_rtc_mode(&biz->gb, realtime ? GB_RTC_MODE_SYNC_TO_HOST : GB_RTC_MODE_ACCURATE);
GB_set_emulate_joypad_bouncing(&biz->gb, !nobounce);
GB_set_allow_illegal_inputs(&biz->gb, true);
biz->blip_l = blip_new(1024);
biz->blip_r = blip_new(1024);
blip_set_rates(biz->blip_l, GB_get_clock_rate(&biz->gb) / 2 / 8, 44100);
blip_set_rates(biz->blip_r, GB_get_clock_rate(&biz->gb) / 2 / 8, 44100);
return biz;
}
EXPORT void sameboy_destroy(biz_t* biz)
{
GB_free(&biz->gb);
blip_delete(biz->blip_l);
blip_delete(biz->blip_r);
free(biz);
}
EXPORT bool sameboy_loadgbs(biz_t* biz, u8* gbs, u32 gbslen, GB_gbs_info_t* gbsinfo)
{
return GB_load_gbs_from_buffer(&biz->gb, gbs, gbslen, gbsinfo) == 0;
}
EXPORT void sameboy_switchgbstrack(biz_t* biz, u32 track)
{
GB_gbs_switch_track(&biz->gb, track);
}
EXPORT void sameboy_setinputcallback(biz_t* biz, input_callback_t callback)
{
biz->input_cb = callback;
}
EXPORT void sameboy_setrumblecallback(biz_t* biz, rumble_callback_t callback)
{
biz->rumble_cb = callback;
}
static inline double FromRawToG(u16 raw)
{
return (raw - 0x81D0) / (0x70 * 1.0);
}
EXPORT void sameboy_frameadvance(biz_t* biz, GB_key_mask_t keys, u16 x, u16 y, s16* sbuf, u32* nsamp, u32* vbuf, bool render, bool border)
{
GB_set_key_mask(&biz->gb, keys);
if (GB_has_accelerometer(&biz->gb))
{
GB_set_accelerometer_values(&biz->gb, FromRawToG(x), FromRawToG(y));
}
GB_set_border_mode(&biz->gb, border ? GB_BORDER_ALWAYS : GB_BORDER_NEVER);
GB_set_rendering_disabled(&biz->gb, !render);
// todo: switch this hack over to joyp_accessed when upstream fixes problems with it
if ((PeekIO(biz, GB_IO_JOYP) & 0x30) != 0x30)
{
biz->input_cb();
}
u32 cycles = 0;
biz->vblank_occurred = false;
biz->new_frame_present = false;
do
{
u8 oldjoyp = PeekIO(biz, GB_IO_JOYP) & 0x30;
u32 ret = GB_run(&biz->gb) >> 2;
cycles += ret;
biz->cc += ret;
u8 newjoyp = PeekIO(biz, GB_IO_JOYP) & 0x30;
if (oldjoyp != newjoyp && newjoyp != 0x30)
{
biz->input_cb();
}
}
while (!biz->vblank_occurred && cycles < 35112);
blip_end_frame(biz->blip_l, biz->nsamps);
blip_end_frame(biz->blip_r, biz->nsamps);
biz->nsamps = 0;
u32 samps = blip_samples_avail(biz->blip_l);
blip_read_samples(biz->blip_l, sbuf + 0, samps, 1);
blip_read_samples(biz->blip_r, sbuf + 1, samps, 1);
*nsamp = samps;
if (biz->new_frame_present && render)
{
memcpy(vbuf, biz->vbuf, sizeof biz->vbuf);
}
}
EXPORT void sameboy_reset(biz_t* biz)
{
GB_random_seed(0);
GB_reset(&biz->gb);
}
EXPORT bool sameboy_iscgbdmg(biz_t* biz)
{
return !GB_is_cgb_in_cgb_mode(&biz->gb);
}
EXPORT void sameboy_savesram(biz_t* biz, u8* dest)
{
GB_save_battery_to_buffer(&biz->gb, dest, GB_save_battery_size(&biz->gb));
}
EXPORT void sameboy_loadsram(biz_t* biz, u8* data, u32 len)
{
GB_load_battery_from_buffer(&biz->gb, data, len);
}
EXPORT u32 sameboy_sramlen(biz_t* biz)
{
return GB_save_battery_size(&biz->gb);
}
EXPORT void sameboy_savestate(biz_t* biz, u8* data)
{
GB_save_state_to_buffer(&biz->gb, data);
}
EXPORT u32 sameboy_loadstate(biz_t* biz, u8* data, u32 len)
{
return GB_load_state_from_buffer(&biz->gb, data, len);
}
EXPORT u32 sameboy_statelen(biz_t* biz)
{
return GB_get_save_state_size(&biz->gb);
}
static void UpdatePal(biz_t* biz, bool bg)
{
u32* pal = bg ? biz->bg_pal : biz->obj_pal;
if (GB_is_cgb_in_cgb_mode(&biz->gb))
{
u16* rawPal = GB_get_direct_access(&biz->gb, bg ? GB_DIRECT_ACCESS_BGP : GB_DIRECT_ACCESS_OBP, NULL, NULL);
for (u32 i = 0; i < 0x20; i++)
{
pal[i] = GB_convert_rgb15(&biz->gb, rawPal[i] & 0x7FFF, false);
}
}
else
{
if (bg)
{
u32 bgPal[4];
if (GB_is_cgb(&biz->gb))
{
u16* rawPal = GB_get_direct_access(&biz->gb, GB_DIRECT_ACCESS_BGP, NULL, NULL);
for (u32 i = 0; i < 4; i++)
{
bgPal[i] = GB_convert_rgb15(&biz->gb, rawPal[i] & 0x7FFF, false);
}
}
else
{
const GB_palette_t* rawPal = GB_get_palette(&biz->gb);
for (u32 i = 0; i < 4; i++)
{
bgPal[3 - i] = rgb_cb(&biz->gb, rawPal->colors[i].r, rawPal->colors[i].g, rawPal->colors[i].b);
}
}
u8 bgp = PeekIO(biz, GB_IO_BGP);
for (u32 i = 0; i < 4; i++)
{
pal[i] = bgPal[(bgp >> (i * 2)) & 3];
}
for (u32 i = 4; i < 0x20; i++)
{
pal[i] = GB_convert_rgb15(&biz->gb, 0x7FFF, false);
}
}
else
{
u32 obj0Pal[4];
u32 obj1Pal[4];
if (GB_is_cgb(&biz->gb))
{
u16* rawPal = GB_get_direct_access(&biz->gb, GB_DIRECT_ACCESS_OBP, NULL, NULL);
for (u32 i = 0; i < 4; i++)
{
obj0Pal[i] = GB_convert_rgb15(&biz->gb, rawPal[i + 0] & 0x7FFF, false);
obj1Pal[i] = GB_convert_rgb15(&biz->gb, rawPal[i + 4] & 0x7FFF, false);
}
}
else
{
const GB_palette_t* rawPal = GB_get_palette(&biz->gb);
for (u32 i = 0; i < 4; i++)
{
obj0Pal[3 - i] = rgb_cb(&biz->gb, rawPal->colors[i].r, rawPal->colors[i].g, rawPal->colors[i].b);
obj1Pal[3 - i] = rgb_cb(&biz->gb, rawPal->colors[i].r, rawPal->colors[i].g, rawPal->colors[i].b);
}
}
u8 obp0 = PeekIO(biz, GB_IO_OBP0);
u8 obp1 = PeekIO(biz, GB_IO_OBP1);
for (u32 i = 0; i < 4; i++)
{
pal[i + 0] = obj0Pal[(obp0 >> (i * 2)) & 3];
pal[i + 4] = obj1Pal[(obp1 >> (i * 2)) & 3];
}
for (u32 i = 8; i < 0x20; i++)
{
pal[i] = GB_convert_rgb15(&biz->gb, 0x7FFF, false);
}
}
}
}
EXPORT bool sameboy_getmemoryarea(biz_t* biz, GB_direct_access_t which, void** data, size_t* len)
{
if (which == GB_DIRECT_ACCESS_IE + 1)
{
UpdatePal(biz, true);
*data = biz->bg_pal;
*len = sizeof biz->bg_pal;
return true;
}
else if (which == GB_DIRECT_ACCESS_IE + 2)
{
UpdatePal(biz, false);
*data = biz->obj_pal;
*len = sizeof biz->obj_pal;
return true;
}
if (which > GB_DIRECT_ACCESS_IE || which < GB_DIRECT_ACCESS_ROM)
{
return false;
}
*data = GB_get_direct_access(&biz->gb, which, len, NULL);
return true;
}
EXPORT u8 sameboy_cpuread(biz_t* biz, u16 addr)
{
GB_set_read_memory_callback(&biz->gb, NULL);
u8 ret = GB_safe_read_memory(&biz->gb, addr);
GB_set_read_memory_callback(&biz->gb, biz->read_cb ? ReadCallbackRelay : NULL);
return ret;
}
EXPORT void sameboy_cpuwrite(biz_t* biz, u16 addr, u8 value)
{
GB_set_write_memory_callback(&biz->gb, NULL);
GB_write_memory(&biz->gb, addr, value);
GB_set_write_memory_callback(&biz->gb, biz->write_cb ? WriteCallbackRelay : NULL);
}
EXPORT u64 sameboy_getcyclecount(biz_t* biz)
{
return biz->cc;
}
EXPORT void sameboy_setcyclecount(biz_t* biz, u64 newCc)
{
biz->cc = newCc;
}
EXPORT void sameboy_settracecallback(biz_t* biz, trace_callback_t callback)
{
biz->trace_cb = callback;
GB_set_execution_callback(&biz->gb, (callback || biz->exec_cb) ? ExecCallbackRelay : NULL);
}
EXPORT void sameboy_getregs(biz_t* biz, u32* buf)
{
GB_registers_t* regs = GB_get_registers(&biz->gb);
buf[0] = regs->pc & 0xFFFF;
buf[1] = regs->a & 0xFF;
buf[2] = regs->f & 0xFF;
buf[3] = regs->b & 0xFF;
buf[4] = regs->c & 0xFF;
buf[5] = regs->d & 0xFF;
buf[6] = regs->e & 0xFF;
buf[7] = regs->h & 0xFF;
buf[8] = regs->l & 0xFF;
buf[9] = regs->sp & 0xFFFF;
}
EXPORT void sameboy_setreg(biz_t* biz, u32 which, u32 value)
{
GB_registers_t* regs = GB_get_registers(&biz->gb);
switch (which)
{
case 0:
regs->pc = value & 0xFFFF;
break;
case 1:
regs->a = value & 0xFF;
break;
case 2:
regs->f = value & 0xFF;
break;
case 3:
regs->b = value & 0xFF;
break;
case 4:
regs->c = value & 0xFF;
break;
case 5:
regs->d = value & 0xFF;
break;
case 6:
regs->e = value & 0xFF;
break;
case 7:
regs->h = value & 0xFF;
break;
case 8:
regs->l = value & 0xFF;
break;
case 9:
regs->sp = value & 0xFFFF;
break;
}
}
EXPORT void sameboy_setmemorycallback(biz_t* biz, u32 which, memory_callback_t callback)
{
switch (which)
{
case 0:
biz->read_cb = callback;
GB_set_read_memory_callback(&biz->gb, callback ? ReadCallbackRelay : NULL);
break;
case 1:
biz->write_cb = callback;
GB_set_write_memory_callback(&biz->gb, callback ? WriteCallbackRelay : NULL);
break;
case 2:
biz->exec_cb = callback;
GB_set_execution_callback(&biz->gb, (callback || biz->trace_cb) ? ExecCallbackRelay : NULL);
break;
}
}
EXPORT void sameboy_setprintercallback(biz_t* biz, printer_callback_t callback)
{
biz->printer_cb = callback;
if (callback)
{
GB_connect_printer(&biz->gb, PrinterCallbackRelay, PrinterDoneCallbackRelay);
}
else
{
GB_disconnect_serial(&biz->gb);
}
}
EXPORT void sameboy_setscanlinecallback(biz_t* biz, scanline_callback_t callback, u32 sl)
{
biz->scanline_cb = callback;
biz->scanline_sl = sl;
GB_set_lcd_line_callback(&biz->gb, callback ? ScanlineCallbackRelay : NULL);
}
EXPORT void sameboy_setrtcdivisoroffset(biz_t* biz, int offset)
{
double base = GB_get_unmultiplied_clock_rate(&biz->gb) * 2.0;
GB_set_rtc_multiplier(&biz->gb, (base + offset) / base);
}
typedef struct
{
u32 palette;
u32 custom_palette[5];
GB_color_correction_mode_t color_correction_mode;
s32 light_temperature;
GB_highpass_mode_t highpass_filter;
s32 interference_volume;
u32 channel_mask;
bool background_enabled;
bool objects_enabled;
} settings_t;
static inline struct GB_color_s argb_to_rgb(u32 argb)
{
struct GB_color_s ret;
ret.r = argb >> 16 & 0xFF;
ret.g = argb >> 8 & 0xFF;
ret.b = argb >> 0 & 0xFF;
return ret;
}
EXPORT void sameboy_setsettings(biz_t* biz, settings_t* settings)
{
for (u32 i = 0; i < 4; i++)
{
biz->custom_pal.colors[3 - i] = argb_to_rgb(settings->custom_palette[i]);
}
biz->custom_pal.colors[4] = argb_to_rgb(settings->custom_palette[4]);
switch (settings->palette)
{
case 0:
GB_set_palette(&biz->gb, &GB_PALETTE_GREY);
break;
case 1:
GB_set_palette(&biz->gb, &GB_PALETTE_DMG);
break;
case 2:
GB_set_palette(&biz->gb, &GB_PALETTE_MGB);
break;
case 3:
GB_set_palette(&biz->gb, &GB_PALETTE_GBL);
break;
case 4:
GB_set_palette(&biz->gb, &biz->custom_pal);
break;
}
for (u32 i = 0; i < GB_N_CHANNELS; i++)
{
GB_set_channel_muted(&biz->gb, i, !(settings->channel_mask >> i & 1));
}
GB_set_color_correction_mode(&biz->gb, settings->color_correction_mode);
GB_set_light_temperature(&biz->gb, settings->light_temperature / 10.0);
GB_set_highpass_filter_mode(&biz->gb, settings->highpass_filter);
GB_set_interference_volume(&biz->gb, settings->interference_volume / 100.0);
GB_set_background_rendering_disabled(&biz->gb, !settings->background_enabled);
GB_set_object_rendering_disabled(&biz->gb, !settings->objects_enabled);
}
Reference in New Issue View Git Blame Copy Permalink