2016-03-30 20:07:55 +00:00
|
|
|
#include <stdbool.h>
|
2018-03-28 18:59:27 +00:00
|
|
|
#include <stdio.h>
|
2016-07-17 19:43:23 +00:00
|
|
|
#include <signal.h>
|
2019-06-01 11:29:46 +00:00
|
|
|
#include <OpenDialog/open_dialog.h>
|
2019-06-26 03:01:54 +00:00
|
|
|
#include <SDL.h>
|
2017-10-12 21:02:02 +00:00
|
|
|
#include <Core/gb.h>
|
2017-05-24 18:44:43 +00:00
|
|
|
#include "utils.h"
|
2017-10-04 09:43:31 +00:00
|
|
|
#include "gui.h"
|
2017-12-23 15:29:42 +00:00
|
|
|
#include "shader.h"
|
2017-05-24 17:33:39 +00:00
|
|
|
|
2018-06-26 16:36:14 +00:00
|
|
|
|
2016-08-20 14:51:17 +00:00
|
|
|
#ifndef _WIN32
|
|
|
|
#define AUDIO_FREQUENCY 96000
|
|
|
|
#else
|
2020-01-02 09:50:55 +00:00
|
|
|
#include <Windows.h>
|
2018-05-11 10:29:58 +00:00
|
|
|
/* Windows (well, at least my VM) can't handle 96KHz sound well :( */
|
2018-04-22 13:22:10 +00:00
|
|
|
|
2018-05-11 10:29:58 +00:00
|
|
|
/* felsqualle says: For SDL 2.0.6+ using the WASAPI driver, the highest freq.
|
2018-04-22 13:22:10 +00:00
|
|
|
we can get is 48000. 96000 also works, but always has some faint crackling in
|
|
|
|
the audio, no matter how high or low I set the buffer length...
|
|
|
|
Not quite satisfied with that solution, because acc. to SDL2 docs,
|
|
|
|
96k + WASAPI *should* work. */
|
|
|
|
|
|
|
|
#define AUDIO_FREQUENCY 48000
|
2016-08-20 14:51:17 +00:00
|
|
|
#endif
|
2016-03-30 20:07:55 +00:00
|
|
|
|
2019-07-16 20:14:26 +00:00
|
|
|
/* Compatibility with older SDL versions */
|
|
|
|
#ifndef SDL_AUDIO_ALLOW_SAMPLES_CHANGE
|
|
|
|
#define SDL_AUDIO_ALLOW_SAMPLES_CHANGE 0
|
|
|
|
#endif
|
|
|
|
|
2017-05-24 18:44:43 +00:00
|
|
|
GB_gameboy_t gb;
|
|
|
|
static bool paused = false;
|
2019-05-18 15:45:31 +00:00
|
|
|
static uint32_t pixel_buffer_1[256 * 224], pixel_buffer_2[256 * 224];
|
2017-12-23 15:41:47 +00:00
|
|
|
static uint32_t *active_pixel_buffer = pixel_buffer_1, *previous_pixel_buffer = pixel_buffer_2;
|
2018-06-22 21:10:28 +00:00
|
|
|
static bool underclock_down = false, rewind_down = false, do_rewind = false, rewind_paused = false, turbo_down = false;
|
|
|
|
static double clock_mutliplier = 1.0;
|
2017-12-23 15:41:47 +00:00
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
static char *filename = NULL;
|
2019-06-01 11:29:46 +00:00
|
|
|
static typeof(free) *free_function = NULL;
|
2017-05-21 18:44:28 +00:00
|
|
|
static char *battery_save_path_ptr;
|
|
|
|
|
2018-05-11 10:29:58 +00:00
|
|
|
SDL_AudioDeviceID device_id;
|
2018-04-22 13:22:10 +00:00
|
|
|
|
2019-06-01 11:29:46 +00:00
|
|
|
void set_filename(const char *new_filename, typeof(free) *new_free_function)
|
2017-10-04 09:43:31 +00:00
|
|
|
{
|
2019-06-01 11:29:46 +00:00
|
|
|
if (filename && free_function) {
|
|
|
|
free_function(filename);
|
2017-10-04 09:43:31 +00:00
|
|
|
}
|
|
|
|
filename = (char *) new_filename;
|
2019-06-01 11:29:46 +00:00
|
|
|
free_function = new_free_function;
|
2017-10-04 09:43:31 +00:00
|
|
|
}
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
static SDL_AudioSpec want_aspec, have_aspec;
|
|
|
|
|
2017-05-25 20:28:48 +00:00
|
|
|
static char *captured_log = NULL;
|
|
|
|
|
|
|
|
static void log_capture_callback(GB_gameboy_t *gb, const char *string, GB_log_attributes attributes)
|
|
|
|
{
|
|
|
|
size_t current_len = strlen(captured_log);
|
|
|
|
size_t len_to_add = strlen(string);
|
|
|
|
captured_log = realloc(captured_log, current_len + len_to_add + 1);
|
|
|
|
memcpy(captured_log + current_len, string, len_to_add);
|
|
|
|
captured_log[current_len + len_to_add] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_capturing_logs(void)
|
|
|
|
{
|
|
|
|
if (captured_log != NULL) {
|
|
|
|
free(captured_log);
|
|
|
|
}
|
|
|
|
captured_log = malloc(1);
|
|
|
|
captured_log[0] = 0;
|
|
|
|
GB_set_log_callback(&gb, log_capture_callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *end_capturing_logs(bool show_popup, bool should_exit)
|
|
|
|
{
|
|
|
|
GB_set_log_callback(&gb, NULL);
|
|
|
|
if (captured_log[0] == 0) {
|
|
|
|
free(captured_log);
|
|
|
|
captured_log = NULL;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (show_popup) {
|
|
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", captured_log, window);
|
|
|
|
}
|
|
|
|
if (should_exit) {
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return captured_log;
|
|
|
|
}
|
|
|
|
|
2018-06-23 19:27:05 +00:00
|
|
|
static void open_menu(void)
|
|
|
|
{
|
|
|
|
bool audio_playing = SDL_GetAudioDeviceStatus(device_id) == SDL_AUDIO_PLAYING;
|
|
|
|
if (audio_playing) {
|
|
|
|
SDL_PauseAudioDevice(device_id, 1);
|
|
|
|
}
|
|
|
|
run_gui(true);
|
2019-11-03 03:43:25 +00:00
|
|
|
SDL_ShowCursor(SDL_DISABLE);
|
2018-06-23 19:27:05 +00:00
|
|
|
if (audio_playing) {
|
2019-07-11 22:53:06 +00:00
|
|
|
SDL_ClearQueuedAudio(device_id);
|
2018-06-23 19:27:05 +00:00
|
|
|
SDL_PauseAudioDevice(device_id, 0);
|
|
|
|
}
|
|
|
|
GB_set_color_correction_mode(&gb, configuration.color_correction_mode);
|
|
|
|
GB_set_highpass_filter_mode(&gb, configuration.highpass_mode);
|
|
|
|
}
|
|
|
|
|
2017-05-21 18:44:28 +00:00
|
|
|
static void handle_events(GB_gameboy_t *gb)
|
2016-03-30 20:07:55 +00:00
|
|
|
{
|
|
|
|
SDL_Event event;
|
|
|
|
while (SDL_PollEvent(&event))
|
|
|
|
{
|
2017-05-24 17:33:39 +00:00
|
|
|
switch (event.type) {
|
2016-03-30 20:07:55 +00:00
|
|
|
case SDL_QUIT:
|
2017-10-14 11:10:26 +00:00
|
|
|
pending_command = GB_SDL_QUIT_COMMAND;
|
|
|
|
break;
|
2017-05-21 18:44:28 +00:00
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
case SDL_DROPFILE: {
|
2019-06-01 11:29:46 +00:00
|
|
|
set_filename(event.drop.file, SDL_free);
|
2017-05-23 20:18:16 +00:00
|
|
|
pending_command = GB_SDL_NEW_FILE_COMMAND;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-05-24 17:33:39 +00:00
|
|
|
case SDL_WINDOWEVENT: {
|
2019-11-03 03:31:23 +00:00
|
|
|
if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
|
2017-05-24 17:33:39 +00:00
|
|
|
update_viewport();
|
|
|
|
}
|
2017-12-22 22:39:04 +00:00
|
|
|
break;
|
2017-05-24 17:33:39 +00:00
|
|
|
}
|
|
|
|
|
2017-12-22 22:39:04 +00:00
|
|
|
case SDL_JOYBUTTONUP:
|
2018-06-23 19:27:05 +00:00
|
|
|
case SDL_JOYBUTTONDOWN: {
|
|
|
|
joypad_button_t button = get_joypad_button(event.jbutton.button);
|
|
|
|
if ((GB_key_t) button < GB_KEY_MAX) {
|
|
|
|
GB_set_key_state(gb, (GB_key_t) button, event.type == SDL_JOYBUTTONDOWN);
|
2017-12-28 18:22:54 +00:00
|
|
|
}
|
2018-06-23 19:27:05 +00:00
|
|
|
else if (button == JOYPAD_BUTTON_TURBO) {
|
2019-07-11 22:53:06 +00:00
|
|
|
SDL_ClearQueuedAudio(device_id);
|
2018-06-22 21:10:28 +00:00
|
|
|
turbo_down = event.type == SDL_JOYBUTTONDOWN;
|
|
|
|
GB_set_turbo_mode(gb, turbo_down, turbo_down && rewind_down);
|
2017-12-22 22:39:04 +00:00
|
|
|
}
|
2018-06-23 19:27:05 +00:00
|
|
|
else if (button == JOYPAD_BUTTON_SLOW_MOTION) {
|
|
|
|
underclock_down = event.type == SDL_JOYBUTTONDOWN;
|
|
|
|
}
|
|
|
|
else if (button == JOYPAD_BUTTON_REWIND) {
|
|
|
|
rewind_down = event.type == SDL_JOYBUTTONDOWN;
|
|
|
|
if (event.type == SDL_JOYBUTTONUP) {
|
|
|
|
rewind_paused = false;
|
2017-12-23 19:11:44 +00:00
|
|
|
}
|
2018-06-23 19:27:05 +00:00
|
|
|
GB_set_turbo_mode(gb, turbo_down, turbo_down && rewind_down);
|
|
|
|
}
|
|
|
|
else if (button == JOYPAD_BUTTON_MENU && event.type == SDL_JOYBUTTONDOWN) {
|
|
|
|
open_menu();
|
2017-12-22 22:39:04 +00:00
|
|
|
}
|
2018-06-23 19:27:05 +00:00
|
|
|
}
|
2017-12-22 22:39:04 +00:00
|
|
|
break;
|
|
|
|
|
2018-06-23 19:27:05 +00:00
|
|
|
case SDL_JOYAXISMOTION: {
|
2018-06-26 16:36:14 +00:00
|
|
|
static bool axis_active[2] = {false, false};
|
2018-06-23 19:27:05 +00:00
|
|
|
joypad_axis_t axis = get_joypad_axis(event.jaxis.axis);
|
2018-06-26 16:36:14 +00:00
|
|
|
if (axis == JOYPAD_AXISES_X) {
|
|
|
|
if (event.jaxis.value > JOYSTICK_HIGH) {
|
|
|
|
axis_active[0] = true;
|
|
|
|
GB_set_key_state(gb, GB_KEY_RIGHT, true);
|
|
|
|
GB_set_key_state(gb, GB_KEY_LEFT, false);
|
|
|
|
}
|
|
|
|
else if (event.jaxis.value < -JOYSTICK_HIGH) {
|
|
|
|
axis_active[0] = true;
|
|
|
|
GB_set_key_state(gb, GB_KEY_RIGHT, false);
|
|
|
|
GB_set_key_state(gb, GB_KEY_LEFT, true);
|
|
|
|
}
|
|
|
|
else if (axis_active[0] && event.jaxis.value < JOYSTICK_LOW && event.jaxis.value > -JOYSTICK_LOW) {
|
|
|
|
axis_active[0] = false;
|
|
|
|
GB_set_key_state(gb, GB_KEY_RIGHT, false);
|
|
|
|
GB_set_key_state(gb, GB_KEY_LEFT, false);
|
|
|
|
}
|
2017-12-22 22:39:04 +00:00
|
|
|
}
|
2018-06-26 16:36:14 +00:00
|
|
|
else if (axis == JOYPAD_AXISES_Y) {
|
|
|
|
if (event.jaxis.value > JOYSTICK_HIGH) {
|
|
|
|
axis_active[1] = true;
|
|
|
|
GB_set_key_state(gb, GB_KEY_DOWN, true);
|
|
|
|
GB_set_key_state(gb, GB_KEY_UP, false);
|
|
|
|
}
|
|
|
|
else if (event.jaxis.value < -JOYSTICK_HIGH) {
|
|
|
|
axis_active[1] = true;
|
|
|
|
GB_set_key_state(gb, GB_KEY_DOWN, false);
|
|
|
|
GB_set_key_state(gb, GB_KEY_UP, true);
|
|
|
|
}
|
|
|
|
else if (axis_active[1] && event.jaxis.value < JOYSTICK_LOW && event.jaxis.value > -JOYSTICK_LOW) {
|
|
|
|
axis_active[1] = false;
|
|
|
|
GB_set_key_state(gb, GB_KEY_DOWN, false);
|
|
|
|
GB_set_key_state(gb, GB_KEY_UP, false);
|
|
|
|
}
|
2017-12-22 22:39:04 +00:00
|
|
|
}
|
2018-06-23 19:27:05 +00:00
|
|
|
}
|
2017-12-22 22:39:04 +00:00
|
|
|
break;
|
2018-06-02 22:21:43 +00:00
|
|
|
|
|
|
|
case SDL_JOYHATMOTION:
|
|
|
|
{
|
|
|
|
uint8_t value = event.jhat.value;
|
|
|
|
int8_t updown =
|
|
|
|
value == SDL_HAT_LEFTUP || value == SDL_HAT_UP || value == SDL_HAT_RIGHTUP ? -1 : (value == SDL_HAT_LEFTDOWN || value == SDL_HAT_DOWN || value == SDL_HAT_RIGHTDOWN ? 1 : 0);
|
|
|
|
int8_t leftright =
|
|
|
|
value == SDL_HAT_LEFTUP || value == SDL_HAT_LEFT || value == SDL_HAT_LEFTDOWN ? -1 : (value == SDL_HAT_RIGHTUP || value == SDL_HAT_RIGHT || value == SDL_HAT_RIGHTDOWN ? 1 : 0);
|
|
|
|
|
|
|
|
GB_set_key_state(gb, GB_KEY_LEFT, leftright == -1);
|
|
|
|
GB_set_key_state(gb, GB_KEY_RIGHT, leftright == 1);
|
|
|
|
GB_set_key_state(gb, GB_KEY_UP, updown == -1);
|
|
|
|
GB_set_key_state(gb, GB_KEY_DOWN, updown == 1);
|
|
|
|
break;
|
|
|
|
};
|
2017-12-22 22:39:04 +00:00
|
|
|
|
2016-03-30 20:07:55 +00:00
|
|
|
case SDL_KEYDOWN:
|
2017-10-14 17:24:13 +00:00
|
|
|
switch (event.key.keysym.scancode) {
|
2017-12-23 19:11:44 +00:00
|
|
|
case SDL_SCANCODE_ESCAPE: {
|
2018-06-23 19:27:05 +00:00
|
|
|
open_menu();
|
2017-10-13 22:41:51 +00:00
|
|
|
break;
|
2017-12-23 19:11:44 +00:00
|
|
|
}
|
2017-10-14 17:24:13 +00:00
|
|
|
case SDL_SCANCODE_C:
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.type == SDL_KEYDOWN && (event.key.keysym.mod & KMOD_CTRL)) {
|
2017-05-21 18:44:28 +00:00
|
|
|
GB_debugger_break(gb);
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2017-10-14 17:24:13 +00:00
|
|
|
case SDL_SCANCODE_R:
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
2017-05-21 18:44:28 +00:00
|
|
|
pending_command = GB_SDL_RESET_COMMAND;
|
|
|
|
}
|
|
|
|
break;
|
2019-06-01 11:29:46 +00:00
|
|
|
|
|
|
|
case SDL_SCANCODE_O: {
|
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
|
|
|
char *filename = do_open_rom_dialog();
|
|
|
|
if (filename) {
|
|
|
|
set_filename(filename, free);
|
|
|
|
pending_command = GB_SDL_NEW_FILE_COMMAND;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2017-05-24 17:33:39 +00:00
|
|
|
|
2017-10-14 17:24:13 +00:00
|
|
|
case SDL_SCANCODE_P:
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
2017-05-24 17:33:39 +00:00
|
|
|
paused = !paused;
|
|
|
|
}
|
|
|
|
break;
|
2017-10-14 17:24:13 +00:00
|
|
|
case SDL_SCANCODE_M:
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
2017-05-21 18:44:28 +00:00
|
|
|
#ifdef __APPLE__
|
2017-05-23 20:18:16 +00:00
|
|
|
// Can't override CMD+M (Minimize) in SDL
|
2017-05-25 20:28:48 +00:00
|
|
|
if (!(event.key.keysym.mod & KMOD_SHIFT)) {
|
2017-05-21 18:44:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2018-05-11 10:29:58 +00:00
|
|
|
bool audio_playing = SDL_GetAudioDeviceStatus(device_id) == SDL_AUDIO_PLAYING;
|
|
|
|
if (audio_playing) {
|
|
|
|
SDL_PauseAudioDevice(device_id, 1);
|
|
|
|
}
|
|
|
|
else if (!audio_playing) {
|
2019-07-11 22:53:06 +00:00
|
|
|
SDL_ClearQueuedAudio(device_id);
|
2018-05-11 10:29:58 +00:00
|
|
|
SDL_PauseAudioDevice(device_id, 0);
|
|
|
|
}
|
2018-04-22 13:22:10 +00:00
|
|
|
}
|
|
|
|
break;
|
2018-04-18 17:22:08 +00:00
|
|
|
|
|
|
|
case SDL_SCANCODE_F:
|
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
|
|
|
if ((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP) == false) {
|
|
|
|
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SDL_SetWindowFullscreen(window, 0);
|
|
|
|
}
|
2019-12-31 22:17:54 +00:00
|
|
|
update_viewport();
|
2018-04-18 17:22:08 +00:00
|
|
|
}
|
|
|
|
break;
|
2017-05-21 18:44:28 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
/* Save states */
|
2018-04-19 12:40:42 +00:00
|
|
|
if (event.key.keysym.scancode >= SDL_SCANCODE_1 && event.key.keysym.scancode <= SDL_SCANCODE_0) {
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.key.keysym.mod & MODIFIER) {
|
2018-05-11 09:51:15 +00:00
|
|
|
command_parameter = (event.key.keysym.scancode - SDL_SCANCODE_1 + 1) % 10;
|
2017-05-21 18:44:28 +00:00
|
|
|
|
2017-05-25 20:28:48 +00:00
|
|
|
if (event.key.keysym.mod & KMOD_SHIFT) {
|
2017-05-21 18:44:28 +00:00
|
|
|
pending_command = GB_SDL_LOAD_STATE_COMMAND;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
pending_command = GB_SDL_SAVE_STATE_COMMAND;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SDL_KEYUP: // Fallthrough
|
2017-12-22 20:25:53 +00:00
|
|
|
if (event.key.keysym.scancode == configuration.keys[8]) {
|
2018-06-22 21:10:28 +00:00
|
|
|
turbo_down = event.type == SDL_KEYDOWN;
|
2019-07-11 22:53:06 +00:00
|
|
|
SDL_ClearQueuedAudio(device_id);
|
2018-06-22 21:10:28 +00:00
|
|
|
GB_set_turbo_mode(gb, turbo_down, turbo_down && rewind_down);
|
|
|
|
}
|
|
|
|
else if (event.key.keysym.scancode == configuration.keys_2[0]) {
|
|
|
|
rewind_down = event.type == SDL_KEYDOWN;
|
|
|
|
if (event.type == SDL_KEYUP) {
|
|
|
|
rewind_paused = false;
|
|
|
|
}
|
|
|
|
GB_set_turbo_mode(gb, turbo_down, turbo_down && rewind_down);
|
|
|
|
}
|
|
|
|
else if (event.key.keysym.scancode == configuration.keys_2[1]) {
|
|
|
|
underclock_down = event.type == SDL_KEYDOWN;
|
2017-12-22 20:25:53 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (unsigned i = 0; i < GB_KEY_MAX; i++) {
|
|
|
|
if (event.key.keysym.scancode == configuration.keys[i]) {
|
|
|
|
GB_set_key_state(gb, i, event.type == SDL_KEYDOWN);
|
|
|
|
}
|
|
|
|
}
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2018-04-22 13:22:10 +00:00
|
|
|
}
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-20 14:51:17 +00:00
|
|
|
static void vblank(GB_gameboy_t *gb)
|
2016-03-30 20:07:55 +00:00
|
|
|
{
|
2018-06-22 21:10:28 +00:00
|
|
|
if (underclock_down && clock_mutliplier > 0.5) {
|
2019-06-19 19:25:59 +00:00
|
|
|
clock_mutliplier -= 1.0/16;
|
2018-06-22 21:10:28 +00:00
|
|
|
GB_set_clock_multiplier(gb, clock_mutliplier);
|
|
|
|
}
|
|
|
|
else if (!underclock_down && clock_mutliplier < 1.0) {
|
2019-06-19 19:25:59 +00:00
|
|
|
clock_mutliplier += 1.0/16;
|
2018-06-22 21:10:28 +00:00
|
|
|
GB_set_clock_multiplier(gb, clock_mutliplier);
|
|
|
|
}
|
2017-12-23 15:41:47 +00:00
|
|
|
if (configuration.blend_frames) {
|
|
|
|
render_texture(active_pixel_buffer, previous_pixel_buffer);
|
|
|
|
uint32_t *temp = active_pixel_buffer;
|
|
|
|
active_pixel_buffer = previous_pixel_buffer;
|
|
|
|
previous_pixel_buffer = temp;
|
|
|
|
GB_set_pixels_output(gb, active_pixel_buffer);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
render_texture(active_pixel_buffer, NULL);
|
|
|
|
}
|
2018-06-22 21:10:28 +00:00
|
|
|
do_rewind = rewind_down;
|
2017-05-21 18:44:28 +00:00
|
|
|
handle_events(gb);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-06-18 17:29:11 +00:00
|
|
|
static uint32_t rgb_encode(GB_gameboy_t *gb, uint8_t r, uint8_t g, uint8_t b)
|
2016-03-30 20:07:55 +00:00
|
|
|
{
|
2017-05-21 18:44:28 +00:00
|
|
|
return SDL_MapRGB(pixel_format, r, g, b);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
|
2016-04-06 19:58:30 +00:00
|
|
|
static void debugger_interrupt(int ignore)
|
|
|
|
{
|
2017-10-14 11:10:26 +00:00
|
|
|
if (!GB_is_inited(&gb)) return;
|
2016-07-18 10:10:19 +00:00
|
|
|
/* ^C twice to exit */
|
2017-04-17 17:16:17 +00:00
|
|
|
if (GB_debugger_is_stopped(&gb)) {
|
2017-10-14 11:10:26 +00:00
|
|
|
GB_save_battery(&gb, battery_save_path_ptr);
|
2016-07-18 10:10:19 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2017-04-17 17:16:17 +00:00
|
|
|
GB_debugger_break(&gb);
|
2016-04-06 19:58:30 +00:00
|
|
|
}
|
|
|
|
|
2019-06-15 20:22:27 +00:00
|
|
|
static void gb_audio_callback(GB_gameboy_t *gb, GB_sample_t *sample)
|
2019-07-11 22:53:06 +00:00
|
|
|
{
|
|
|
|
if (turbo_down) {
|
|
|
|
static unsigned skip = 0;
|
|
|
|
skip++;
|
|
|
|
if (skip == have_aspec.freq / 8) {
|
|
|
|
skip = 0;
|
|
|
|
}
|
|
|
|
if (skip > have_aspec.freq / 16) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SDL_GetQueuedAudioSize(device_id) / sizeof(*sample) > have_aspec.freq / 4) {
|
2019-06-22 16:01:35 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-07-11 22:53:06 +00:00
|
|
|
|
2019-06-15 20:22:27 +00:00
|
|
|
SDL_QueueAudio(device_id, sample, sizeof(*sample));
|
2019-07-11 22:53:06 +00:00
|
|
|
|
2016-05-23 19:22:09 +00:00
|
|
|
}
|
2019-06-15 20:22:27 +00:00
|
|
|
|
2017-05-24 18:44:43 +00:00
|
|
|
|
|
|
|
static bool handle_pending_command(void)
|
2016-07-17 20:08:07 +00:00
|
|
|
{
|
2017-05-24 18:44:43 +00:00
|
|
|
switch (pending_command) {
|
|
|
|
case GB_SDL_LOAD_STATE_COMMAND:
|
|
|
|
case GB_SDL_SAVE_STATE_COMMAND: {
|
|
|
|
char save_path[strlen(filename) + 4];
|
|
|
|
char save_extension[] = ".s0";
|
|
|
|
save_extension[2] += command_parameter;
|
|
|
|
replace_extension(filename, strlen(filename), save_path, save_extension);
|
|
|
|
|
2017-05-25 20:28:48 +00:00
|
|
|
start_capturing_logs();
|
2017-05-24 18:44:43 +00:00
|
|
|
if (pending_command == GB_SDL_LOAD_STATE_COMMAND) {
|
|
|
|
GB_load_state(&gb, save_path);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
GB_save_state(&gb, save_path);
|
|
|
|
}
|
2017-05-25 20:28:48 +00:00
|
|
|
end_capturing_logs(true, false);
|
2017-05-24 18:44:43 +00:00
|
|
|
return false;
|
2016-07-17 20:08:07 +00:00
|
|
|
}
|
2017-05-24 18:44:43 +00:00
|
|
|
|
|
|
|
case GB_SDL_NO_COMMAND:
|
|
|
|
return false;
|
|
|
|
|
2019-11-03 03:50:29 +00:00
|
|
|
case GB_SDL_RESET_COMMAND:
|
2017-05-24 18:44:43 +00:00
|
|
|
case GB_SDL_NEW_FILE_COMMAND:
|
2019-11-03 03:50:29 +00:00
|
|
|
GB_save_battery(&gb, battery_save_path_ptr);
|
2017-05-24 18:44:43 +00:00
|
|
|
return true;
|
|
|
|
|
2017-10-14 11:10:26 +00:00
|
|
|
case GB_SDL_QUIT_COMMAND:
|
|
|
|
GB_save_battery(&gb, battery_save_path_ptr);
|
|
|
|
exit(0);
|
2016-07-17 20:08:07 +00:00
|
|
|
}
|
2017-05-24 18:44:43 +00:00
|
|
|
return false;
|
2016-07-17 20:08:07 +00:00
|
|
|
}
|
2017-05-24 18:44:43 +00:00
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
static void run(void)
|
2016-03-30 20:07:55 +00:00
|
|
|
{
|
2019-11-03 03:43:25 +00:00
|
|
|
SDL_ShowCursor(SDL_DISABLE);
|
2019-05-18 17:37:41 +00:00
|
|
|
GB_model_t model;
|
2017-10-13 22:41:51 +00:00
|
|
|
pending_command = GB_SDL_NO_COMMAND;
|
2017-05-23 20:18:16 +00:00
|
|
|
restart:
|
2019-05-18 17:37:41 +00:00
|
|
|
model = (GB_model_t [])
|
|
|
|
{
|
|
|
|
[MODEL_DMG] = GB_MODEL_DMG_B,
|
|
|
|
[MODEL_CGB] = GB_MODEL_CGB_E,
|
|
|
|
[MODEL_AGB] = GB_MODEL_AGB,
|
|
|
|
[MODEL_SGB] = (GB_model_t [])
|
|
|
|
{
|
|
|
|
[SGB_NTSC] = GB_MODEL_SGB_NTSC,
|
|
|
|
[SGB_PAL] = GB_MODEL_SGB_PAL,
|
|
|
|
[SGB_2] = GB_MODEL_SGB2,
|
|
|
|
}[configuration.sgb_revision],
|
|
|
|
}[configuration.model];
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
if (GB_is_inited(&gb)) {
|
2019-05-18 17:37:41 +00:00
|
|
|
GB_switch_model_and_reset(&gb, model);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
2017-05-23 20:18:16 +00:00
|
|
|
else {
|
2019-05-18 17:37:41 +00:00
|
|
|
GB_init(&gb, model);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
|
|
|
GB_set_vblank_callback(&gb, (GB_vblank_callback_t) vblank);
|
2017-12-23 15:41:47 +00:00
|
|
|
GB_set_pixels_output(&gb, active_pixel_buffer);
|
2017-05-23 20:18:16 +00:00
|
|
|
GB_set_rgb_encode_callback(&gb, rgb_encode);
|
|
|
|
GB_set_sample_rate(&gb, have_aspec.freq);
|
2017-12-22 20:25:53 +00:00
|
|
|
GB_set_color_correction_mode(&gb, configuration.color_correction_mode);
|
2017-12-23 19:11:44 +00:00
|
|
|
GB_set_highpass_filter_mode(&gb, configuration.highpass_mode);
|
2018-06-22 21:10:28 +00:00
|
|
|
GB_set_rewind_length(&gb, configuration.rewind_length);
|
2019-06-07 15:27:25 +00:00
|
|
|
GB_set_update_input_hint_callback(&gb, handle_events);
|
2019-06-15 20:22:27 +00:00
|
|
|
GB_apu_set_sample_callback(&gb, gb_audio_callback);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2019-05-18 15:45:31 +00:00
|
|
|
SDL_DestroyTexture(texture);
|
|
|
|
texture = SDL_CreateTexture(renderer, SDL_GetWindowPixelFormat(window), SDL_TEXTUREACCESS_STREAMING,
|
|
|
|
GB_get_screen_width(&gb), GB_get_screen_height(&gb));
|
|
|
|
|
|
|
|
SDL_SetWindowMinimumSize(window, GB_get_screen_width(&gb), GB_get_screen_height(&gb));
|
|
|
|
|
|
|
|
|
2017-05-27 16:16:07 +00:00
|
|
|
bool error = false;
|
2017-05-25 20:28:48 +00:00
|
|
|
start_capturing_logs();
|
2019-05-18 15:45:31 +00:00
|
|
|
const char * const boot_roms[] = {"dmg_boot.bin", "cgb_boot.bin", "agb_boot.bin", "sgb_boot.bin"};
|
2019-05-18 17:37:41 +00:00
|
|
|
const char *boot_rom = boot_roms[configuration.model];
|
2019-07-16 20:14:26 +00:00
|
|
|
if (configuration.model == MODEL_SGB && configuration.sgb_revision == SGB_2) {
|
2019-05-18 17:37:41 +00:00
|
|
|
boot_rom = "sgb2_boot.bin";
|
|
|
|
}
|
|
|
|
error = GB_load_boot_rom(&gb, resource_path(boot_rom));
|
2017-05-27 16:16:07 +00:00
|
|
|
end_capturing_logs(true, error);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2017-05-25 20:28:48 +00:00
|
|
|
start_capturing_logs();
|
2017-05-27 16:16:07 +00:00
|
|
|
error = GB_load_rom(&gb, filename);
|
|
|
|
end_capturing_logs(true, error);
|
2016-03-30 20:07:55 +00:00
|
|
|
|
2016-07-18 11:37:06 +00:00
|
|
|
size_t path_length = strlen(filename);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2016-07-17 20:08:07 +00:00
|
|
|
/* Configure battery */
|
|
|
|
char battery_save_path[path_length + 5]; /* At the worst case, size is strlen(path) + 4 bytes for .sav + NULL */
|
2016-07-18 11:37:06 +00:00
|
|
|
replace_extension(filename, path_length, battery_save_path, ".sav");
|
2017-05-21 18:44:28 +00:00
|
|
|
battery_save_path_ptr = battery_save_path;
|
2016-06-18 17:29:11 +00:00
|
|
|
GB_load_battery(&gb, battery_save_path);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2016-07-17 20:08:07 +00:00
|
|
|
/* Configure symbols */
|
2018-11-09 22:20:57 +00:00
|
|
|
GB_debugger_load_symbol_file(&gb, resource_path("registers.sym"));
|
2017-02-20 12:37:15 +00:00
|
|
|
|
2016-07-17 20:08:07 +00:00
|
|
|
char symbols_path[path_length + 5];
|
2016-07-18 11:37:06 +00:00
|
|
|
replace_extension(filename, path_length, symbols_path, ".sym");
|
2016-07-17 20:08:07 +00:00
|
|
|
GB_debugger_load_symbol_file(&gb, symbols_path);
|
2019-05-18 15:45:31 +00:00
|
|
|
|
|
|
|
update_viewport();
|
|
|
|
|
2016-05-23 19:22:09 +00:00
|
|
|
/* Run emulation */
|
2017-05-21 18:44:28 +00:00
|
|
|
while (true) {
|
2018-06-22 21:10:28 +00:00
|
|
|
if (paused || rewind_paused) {
|
2017-05-24 17:33:39 +00:00
|
|
|
SDL_WaitEvent(NULL);
|
|
|
|
handle_events(&gb);
|
|
|
|
}
|
|
|
|
else {
|
2018-06-22 21:10:28 +00:00
|
|
|
if (do_rewind) {
|
|
|
|
GB_rewind_pop(&gb);
|
|
|
|
if (turbo_down) {
|
|
|
|
GB_rewind_pop(&gb);
|
|
|
|
}
|
|
|
|
if (!GB_rewind_pop(&gb)) {
|
|
|
|
rewind_paused = true;
|
|
|
|
}
|
|
|
|
do_rewind = false;
|
|
|
|
}
|
2017-05-24 17:33:39 +00:00
|
|
|
GB_run(&gb);
|
|
|
|
}
|
2017-05-24 18:44:43 +00:00
|
|
|
|
|
|
|
/* These commands can't run in the handle_event function, because they're not safe in a vblank context. */
|
|
|
|
if (handle_pending_command()) {
|
|
|
|
pending_command = GB_SDL_NO_COMMAND;
|
|
|
|
goto restart;
|
2017-05-21 18:44:28 +00:00
|
|
|
}
|
|
|
|
pending_command = GB_SDL_NO_COMMAND;
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
}
|
2017-12-23 15:29:42 +00:00
|
|
|
|
2017-12-28 19:46:59 +00:00
|
|
|
static char prefs_path[1024] = {0, };
|
|
|
|
|
|
|
|
static void save_configuration(void)
|
|
|
|
{
|
|
|
|
FILE *prefs_file = fopen(prefs_path, "wb");
|
|
|
|
if (prefs_file) {
|
|
|
|
fwrite(&configuration, 1, sizeof(configuration), prefs_file);
|
|
|
|
fclose(prefs_file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-10 14:32:45 +00:00
|
|
|
static bool get_arg_flag(const char *flag, int *argc, char **argv)
|
|
|
|
{
|
|
|
|
for (unsigned i = 1; i < *argc; i++) {
|
|
|
|
if (strcmp(argv[i], flag) == 0) {
|
|
|
|
(*argc)--;
|
|
|
|
argv[i] = argv[*argc];
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2019-12-31 22:27:41 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
SetProcessDPIAware();
|
|
|
|
#endif
|
2017-05-23 20:18:16 +00:00
|
|
|
#define str(x) #x
|
|
|
|
#define xstr(x) str(x)
|
|
|
|
fprintf(stderr, "SameBoy v" xstr(VERSION) "\n");
|
2018-11-10 14:32:45 +00:00
|
|
|
|
|
|
|
bool fullscreen = get_arg_flag("--fullscreen", &argc, argv);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2018-01-13 11:49:20 +00:00
|
|
|
if (argc > 2) {
|
2018-11-10 14:32:45 +00:00
|
|
|
fprintf(stderr, "Usage: %s [--fullscreen] [rom]\n", argv[0]);
|
2017-05-23 20:18:16 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2018-01-13 11:49:20 +00:00
|
|
|
if (argc == 2) {
|
2018-01-22 20:25:27 +00:00
|
|
|
filename = argv[1];
|
2017-05-23 20:18:16 +00:00
|
|
|
}
|
2016-03-30 20:07:55 +00:00
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
signal(SIGINT, debugger_interrupt);
|
|
|
|
|
2018-06-16 10:59:33 +00:00
|
|
|
SDL_Init(SDL_INIT_EVERYTHING);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2017-12-23 15:29:42 +00:00
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
|
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
|
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
window = SDL_CreateWindow("SameBoy v" xstr(VERSION), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
|
2017-12-23 15:29:42 +00:00
|
|
|
160 * 2, 144 * 2, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
|
2017-05-24 17:33:39 +00:00
|
|
|
SDL_SetWindowMinimumSize(window, 160, 144);
|
2017-05-23 20:18:16 +00:00
|
|
|
|
2018-11-10 14:32:45 +00:00
|
|
|
if (fullscreen) {
|
|
|
|
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
|
|
|
|
}
|
|
|
|
|
2017-12-23 15:29:42 +00:00
|
|
|
SDL_GLContext gl_context = SDL_GL_CreateContext(window);
|
2017-12-28 22:43:19 +00:00
|
|
|
|
2017-12-30 15:01:23 +00:00
|
|
|
GLint major = 0, minor = 0;
|
2017-12-28 22:43:19 +00:00
|
|
|
glGetIntegerv(GL_MAJOR_VERSION, &major);
|
|
|
|
glGetIntegerv(GL_MINOR_VERSION, &minor);
|
|
|
|
|
|
|
|
if (major * 0x100 + minor < 0x302) {
|
|
|
|
SDL_GL_DeleteContext(gl_context);
|
|
|
|
gl_context = NULL;
|
|
|
|
}
|
|
|
|
|
2017-12-23 15:29:42 +00:00
|
|
|
if (gl_context == NULL) {
|
|
|
|
renderer = SDL_CreateRenderer(window, -1, 0);
|
|
|
|
texture = SDL_CreateTexture(renderer, SDL_GetWindowPixelFormat(window), SDL_TEXTUREACCESS_STREAMING, 160, 144);
|
|
|
|
pixel_format = SDL_AllocFormat(SDL_GetWindowPixelFormat(window));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
pixel_format = SDL_AllocFormat(SDL_PIXELFORMAT_ABGR8888);
|
|
|
|
}
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
|
|
|
|
/* Configure Audio */
|
|
|
|
memset(&want_aspec, 0, sizeof(want_aspec));
|
|
|
|
want_aspec.freq = AUDIO_FREQUENCY;
|
|
|
|
want_aspec.format = AUDIO_S16SYS;
|
|
|
|
want_aspec.channels = 2;
|
2018-11-10 16:58:22 +00:00
|
|
|
want_aspec.samples = 512;
|
|
|
|
|
|
|
|
SDL_version _sdl_version;
|
|
|
|
SDL_GetVersion(&_sdl_version);
|
|
|
|
unsigned sdl_version = _sdl_version.major * 1000 + _sdl_version.minor * 100 + _sdl_version.patch;
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
/* SDL 2.0.5 on macOS and Linux introduced a bug where certain combinations of buffer lengths and frequencies
|
2018-03-27 20:05:08 +00:00
|
|
|
fail to produce audio correctly. */
|
2018-11-10 16:58:22 +00:00
|
|
|
if (sdl_version >= 2005) {
|
|
|
|
want_aspec.samples = 2048;
|
|
|
|
}
|
2017-05-27 09:29:36 +00:00
|
|
|
#else
|
2019-07-11 22:53:06 +00:00
|
|
|
if (sdl_version < 2006) {
|
2018-11-10 16:58:22 +00:00
|
|
|
/* Since WASAPI audio was introduced in SDL 2.0.6, we have to lower the audio frequency
|
|
|
|
to 44100 because otherwise we would get garbled audio output.*/
|
|
|
|
want_aspec.freq = 44100;
|
|
|
|
}
|
2018-04-22 13:22:10 +00:00
|
|
|
#endif
|
2018-11-10 16:58:22 +00:00
|
|
|
|
2019-07-11 22:53:06 +00:00
|
|
|
device_id = SDL_OpenAudioDevice(0, 0, &want_aspec, &have_aspec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_SAMPLES_CHANGE);
|
2017-05-23 20:18:16 +00:00
|
|
|
/* Start Audio */
|
|
|
|
|
|
|
|
SDL_EventState(SDL_DROPFILE, SDL_ENABLE);
|
|
|
|
|
2017-12-28 19:46:59 +00:00
|
|
|
char *prefs_dir = SDL_GetPrefPath("", "SameBoy");
|
|
|
|
snprintf(prefs_path, sizeof(prefs_path) - 1, "%sprefs.bin", prefs_dir);
|
|
|
|
SDL_free(prefs_dir);
|
|
|
|
|
|
|
|
FILE *prefs_file = fopen(prefs_path, "rb");
|
|
|
|
if (prefs_file) {
|
|
|
|
fread(&configuration, 1, sizeof(configuration), prefs_file);
|
|
|
|
fclose(prefs_file);
|
|
|
|
}
|
2018-06-16 10:59:33 +00:00
|
|
|
if (configuration.model >= MODEL_MAX) {
|
|
|
|
configuration.model = MODEL_CGB;
|
|
|
|
}
|
2017-12-28 19:46:59 +00:00
|
|
|
|
|
|
|
atexit(save_configuration);
|
|
|
|
|
2017-12-23 15:29:42 +00:00
|
|
|
if (!init_shader_with_name(&shader, configuration.filter)) {
|
|
|
|
init_shader_with_name(&shader, "NearestNeighbor");
|
|
|
|
}
|
|
|
|
update_viewport();
|
|
|
|
|
2017-05-23 20:18:16 +00:00
|
|
|
if (filename == NULL) {
|
2017-10-13 22:41:51 +00:00
|
|
|
run_gui(false);
|
2017-05-23 20:18:16 +00:00
|
|
|
}
|
2018-11-10 17:39:57 +00:00
|
|
|
else {
|
|
|
|
connect_joypad();
|
|
|
|
}
|
2018-05-11 10:29:58 +00:00
|
|
|
SDL_PauseAudioDevice(device_id, 0);
|
2017-05-23 20:18:16 +00:00
|
|
|
run(); // Never returns
|
|
|
|
return 0;
|
|
|
|
}
|