static void read_config(void)
{
fse_log("[FSE] Read config\n");
char *string_result;
int fullscreen = fs_config_get_boolean(OPTION_FULLSCREEN);
if (fullscreen != FS_CONFIG_NONE) {
g_fs_emu_video_fullscreen = fullscreen;
}
g_fs_emu_video_fullscreen_mode_string = fs_config_get_string(
OPTION_FULLSCREEN_MODE);
string_result = fs_config_get_string(OPTION_TITLE);
if (string_result) {
g_fs_emu_title = string_result;
}
string_result = fs_config_get_string(OPTION_SUB_TITLE);
if (string_result) {
if (strcmp(string_result, "0") == 0) {
g_fs_emu_sub_title = g_strdup("");
} else {
g_fs_emu_sub_title = string_result;
}
}
}
static int hotkey_function(int key_code, int key_mod) {
//write_log("hotkey: %d mod %d\n", key_code, key_mod);
switch (key_code) {
case FS_ML_KEY_R:
fs_emu_log("hot key: soft reset\n");
fs_emu_warning(_("Soft Reset"));
fs_emu_queue_action(INPUTEVENT_SPC_SOFTRESET, 1);
return 0;
case FS_ML_KEY_T:
fs_emu_log("hot key: hard reset\n");
fs_emu_warning(_("Hard Reset"));
fs_emu_queue_action(INPUTEVENT_SPC_HARDRESET, 1);
return 0;
case FS_ML_KEY_A:
fs_emu_log("hot key: freeze button\n");
fs_emu_queue_action(INPUTEVENT_SPC_FREEZEBUTTON, 1);
return 0;
case FS_ML_KEY_D:
fs_emu_log("hot key: enter debugger\n");
if (fs_config_get_boolean("console_debugger") == 1) {
fs_emu_warning(_("Activated debugger"));
fs_emu_queue_action(INPUTEVENT_SPC_ENTERDEBUGGER, 1);
}
else {
fs_emu_warning(_("Option \"%s\" is not enabled"),
"console_debugger");
}
return 0;
}
return 0;
}
int fs_config_read_file(const char *path, int force) {
if (!g_initialized) {
initialize();
}
fs_log("\n");
fs_log(LOG_LINE);
fs_log("config (%s)\n", path);
fs_log(LOG_LINE);
fs_log("\n");
// FIXME: support checking a config key "end_config", which causes
// later calls to fs_config_read_config_file to be ignored
if (!force && fs_config_get_boolean("end_config") == 1) {
fs_log("end_config is set, ignoring this config file\n");
return 1;
}
if (!fs_path_is_file(path)) {
fs_log("config file %s does not exist\n", path);
return 0;
}
fs_ini_file *ini_file = fs_ini_file_open(path);
if (ini_file == NULL) {
fs_log("error loading config file\n");
return 0;
}
char **groups = fs_ini_file_get_groups(ini_file, NULL);
for (char **group = groups; *group; group++) {
const char *prefix = "";
if (strcmp(*group, "theme") == 0) {
prefix = "theme_";
}
char **keys = fs_ini_file_get_keys(ini_file, *group, NULL);
for (char **key = keys; *key; key++) {
char *value = fs_ini_file_get_value(ini_file, *group, *key);
if (value) {
char *key2 = g_strconcat(prefix, *key, NULL);
process_key_value(key2, value, 0);
g_free(key2);
}
}
g_strfreev(keys);
}
g_strfreev(groups);
fs_ini_file_destroy(ini_file);
return 1;
}
void fs_ml_render_init() {
g_frame_available_cond = fs_condition_create();
g_frame_available_mutex = fs_mutex_create();
g_start_new_frame_cond = fs_condition_create();
g_start_new_frame_mutex = fs_mutex_create();
g_buffer_swap_cond = fs_condition_create();
g_buffer_swap_mutex = fs_mutex_create();
g_epoch = fs_get_monotonic_time();
g_vblank_mutex = fs_mutex_create();
//fs_emu_stat_queue_init(&g_measured_vblank_times, VBLANK_TIMES_COUNT);
if (fs_config_get_boolean("low_latency_vsync") == 1) {
fs_log("using low latency vsync when full vsync is enabled\n");
g_fs_ml_video_sync_low_latency = 1;
}
else if (fs_config_get_boolean("low_latency_vsync") == 0) {
fs_log("disabling use of low latency vsync\n");
g_fs_ml_video_sync_low_latency = 0;
}
}
static void init_i18n()
{
if (fs_config_get_boolean("localization") == 0) {
fs_log("localization was forced off\n");
return;
}
char *locale = setlocale(LC_MESSAGES, "");
if (locale) {
fs_log("locale is set to %s\n", locale);
}
else {
fs_log("failed to set current locale\n");
}
const char *language = fs_config_get_const_string("language");
if (language) {
fs_log("setting LANGUAGE=%s\n", language);
char *env_str = g_strdup_printf("LANGUAGE=%s", language);
#ifdef WINDOWS
_putenv(env_str);
#else
putenv(env_str);
#endif
// don't free env_str, it's put directly in the environment
}
#ifndef ANDROID
textdomain("fs-uae");
char *path = fs_get_data_file("fs-uae/share-dir");
if (path) {
fs_log("using data dir \"%s\"\n", path);
// remove "fs-uae/share-dir" from the returned path
int len = strlen(path);
if (len > 16) {
path[len - 16] = '\0';
}
char *locale_base = g_build_filename(path, "locale", NULL);
fs_log("using locale dir \"%s\"\n", locale_base);
bindtextdomain("fs-uae", locale_base);
free(locale_base);
free(path);
}
bind_textdomain_codeset("fs-uae", "UTF-8");
#endif
}
static void read_config() {
char *string_result;
int fullscreen = fs_config_get_boolean("fullscreen");
if (fullscreen != FS_CONFIG_NONE) {
g_fs_emu_video_fullscreen = fullscreen;
}
g_fs_emu_video_fullscreen_mode_string = fs_config_get_string("fullscreen_mode");
string_result = fs_config_get_string("title");
if (string_result) {
g_fs_emu_title = string_result;
}
string_result = fs_config_get_string("sub_title");
if (string_result) {
g_fs_emu_sub_title = string_result;
}
}
void fs_config_set_log_file(const char *path)
{
fs_log("switch to log file %s\n", path);
fs_mutex_lock(log.mutex);
if (log.file) {
fclose(log.file);
}
log.file = g_fopen(path, "w");
if (log.file) {
printf("LOG: %s\n", path);
if (log.initial_path) {
FILE *f = g_fopen(log.initial_path, "r");
if (f) {
char *buffer = (char *) g_malloc(1024);
int read = fread(buffer, 1, 1024, f);
while (read > 0) {
fwrite(buffer, 1, read, log.file);
read = fread(buffer, 1, 1024, f);
}
g_free(buffer);
fclose(f);
}
}
}
/* All options should have been read, so we can no check log options */
if (fs_config_get_boolean("flush_log") == 1) {
log.flush = 1;
}
fs_mutex_unlock(log.mutex);
if (log.flush) {
fs_log_string("flush_log: will flush log after each log line\n");
}
}
void fs_emu_init(void)
{
fs_log("fs_emu_init\n");
//if (!g_fs_emu_config) {
// g_fs_emu_config = g_key_file_new();
//}
fs_time_init();
if (fs_config_get_boolean("stdout") == 1) {
fs_log_enable_stdout();
}
fs_emu_log("calling fs_ml_init\n");
fs_ml_init();
#ifdef WITH_LUA
fs_emu_lua_init();
#endif
g_gui_mutex = fs_mutex_create();
fs_emu_hud_init();
fs_emu_dialog_init();
}
int fs_ml_video_create_window(const char *title) {
fs_log("fs_ml_video_create_window\n");
g_window_title = g_strdup(title);
g_fs_ml_keyboard_input_grab = fs_config_get_boolean(
"keyboard_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
g_fs_ml_keyboard_input_grab = 1;
}
fs_log("keyboard input grab: %d\n", g_fs_ml_keyboard_input_grab);
static int initialized = 0;
#ifdef USE_SDL2
SDL_SetHint(SDL_HINT_GRAB_KEYBOARD,
g_fs_ml_keyboard_input_grab ? "1" : "0");
#endif
SDL_Init(SDL_INIT_VIDEO);
SDL_version version;
SDL_VERSION(&version);
fs_log("FS-UAE was compiled for SDL %d.%d.%d\n",
version.major, version.minor, version.patch);
if (!initialized) {
#ifdef USE_SDL2
int display_index = 0;
SDL_DisplayMode mode;
int should_be_zero = SDL_GetCurrentDisplayMode(display_index, &mode);
if(should_be_zero != 0) {
fs_log("SDL_GetCurrentDisplayMode failed\n");
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Display Error",
"SDL_GetCurrentDisplayMode failed.", NULL);
exit(1);
}
#else
const SDL_VideoInfo* info = SDL_GetVideoInfo();
#endif
g_fullscreen_width = fs_config_get_int("fullscreen_width");
if (g_fullscreen_width == FS_CONFIG_NONE) {
#ifdef USE_SDL2
g_fullscreen_width = mode.w;
#else
g_fullscreen_width = info->current_w;
#endif
}
g_fullscreen_height = fs_config_get_int("fullscreen_height");
if (g_fullscreen_height == FS_CONFIG_NONE) {
#ifdef USE_SDL2
g_fullscreen_height = mode.h;
#else
g_fullscreen_height = info->current_h;
#endif
}
if (g_fs_emu_video_fullscreen_mode_string == NULL) {
g_fs_emu_video_fullscreen_mode = -1;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"window") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_WINDOW;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"fullscreen") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
}
#ifdef USE_SDL2
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"desktop") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
#endif
if (g_fs_emu_video_fullscreen_mode == -1) {
#ifdef MACOSX
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#else
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#endif
#ifdef USE_SDL2
fs_log("defaulting to fullscreen_mode = desktop for SDL2\n");
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
#endif
}
initialized = 1;
}
if (g_fs_ml_video_sync) {
g_fs_ml_vblank_sync = 1;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
#ifdef USE_SDL2
// setting swap interval after creating OpenGL context
#else
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** Setting swap interval to 1 ***\n");
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
}
else {
fs_emu_log("*** Setting swap interval to 0 ***\n");
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 0);
}
#endif
if (g_fsaa) {
fs_log("setting FSAA samples to %d\n", g_fsaa);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, g_fsaa);
}
g_window_width = fs_config_get_int("window_width");
if (g_window_width == FS_CONFIG_NONE) {
g_window_width = 1920 / 2;
}
g_window_height = fs_config_get_int("window_height");
if (g_window_height == FS_CONFIG_NONE) {
g_window_height = 1080/ 2;
}
#ifdef USE_SDL2
g_window_x = fs_config_get_int("window_x");
if (g_window_x == FS_CONFIG_NONE) {
g_window_x = SDL_WINDOWPOS_CENTERED;
}
g_window_y = fs_config_get_int("window_y");
if (g_window_y == FS_CONFIG_NONE) {
g_window_y = SDL_WINDOWPOS_CENTERED;
}
#endif
g_window_resizable = fs_config_get_boolean("window_resizable");
if (g_window_resizable == FS_CONFIG_NONE) {
g_window_resizable = 1;
}
g_fs_ml_automatic_input_grab = fs_config_get_boolean(
"automatic_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
if (fs_ml_mouse_integration()) {
g_fs_ml_automatic_input_grab = 0;
} else {
g_fs_ml_automatic_input_grab = 1;
}
}
fs_log("automatic input grab: %d\n", g_fs_ml_automatic_input_grab);
g_initial_input_grab = g_fs_ml_automatic_input_grab;
if (fs_config_get_boolean("initial_input_grab") == 1) {
g_initial_input_grab = 1;
}
else if (fs_config_get_boolean("initial_input_grab") == 0 ||
// deprecated names:
fs_config_get_boolean("input_grab") == 0 ||
fs_config_get_boolean("grab_input") == 0) {
g_initial_input_grab = 0;
}
set_video_mode();
#ifdef USE_SDL2
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** Setting swap interval to 1 ***\n");
if (SDL_GL_SetSwapInterval(1) != 0) {
fs_emu_warning("SDL_GL_SetSwapInterval(1) failed");
}
}
else {
fs_emu_log("*** Setting swap interval to 0 ***\n");
SDL_GL_SetSwapInterval(0);
}
#endif
// we display a black frame as soon as possible (to reduce flickering on
// startup)
glClear(GL_COLOR_BUFFER_BIT);
#ifdef USE_SDL2
SDL_GL_SwapWindow(g_fs_ml_window);
#else
SDL_GL_SwapBuffers();
#endif
fs_gl_finish();
#ifdef USE_SDL2
// set in SDL_CreateWindow instead
#else
SDL_WM_SetCaption(g_window_title, fs_get_application_name());
#endif
fs_log("initial input grab: %d\n", g_initial_input_grab);
if (g_initial_input_grab && !g_has_input_grab) {
fs_ml_grab_input(1, 1);
}
fs_ml_show_cursor(0, 1);
// this function must be called from the video thread
fs_log("init_opengl\n");
fs_emu_video_init_opengl();
#ifdef WINDOWS
#ifdef USE_SDL2
// we use only SDL functions with SDL2
#else
fs_ml_init_raw_input();
#endif
#else
#ifdef USE_SDL2
SDL_StartTextInput();
#else
// enable keysym to unicode char translation
SDL_EnableUNICODE(1);
#endif
#endif
fs_log("create windows is done\n");
return 1;
}
void fs_uae_reconfigure_input_ports_host()
{
fs_emu_log("fs_uae_reconfigure_input_ports_host\n");
fs_emu_reset_input_mapping();
fs_uae_map_keyboard();
int mouse_mapped_to_port = -1;
for (int i = 0; i < FS_UAE_NUM_INPUT_PORTS; i++) {
fs_uae_input_port *port = g_fs_uae_input_ports + i;
fs_log("configuring joystick port %d\n", i);
if (port->mode == AMIGA_JOYPORT_NONE) {
fs_log("* nothing in port\n");
fs_log("* FIXME\n");
}
else if (port->mode == AMIGA_JOYPORT_MOUSE) {
fs_log("* amiga mouse\n");
// if (strcmp(port->device, "MOUSE") == 0) {
// fs_log("* using host mouse\n");
fs_log("* using device %s\n", port->device);
map_mouse(port->device, i);
mouse_mapped_to_port = i;
// }
// else {
// fs_log("* not mapping host device to amiga mouse\n");
// }
}
else if (port->mode == AMIGA_JOYPORT_DJOY) {
fs_log("* amiga joystick\n");
if (strcmp(port->device, "MOUSE") == 0) {
fs_log("* cannot map mouse to joystick\n");
}
else {
fs_log("* using device %s\n", port->device);
fs_emu_configure_joystick(port->device, "amiga",
g_joystick_mappings[i], 1, NULL, 0, true);
}
}
else if (port->mode == AMIGA_JOYPORT_CD32JOY) {
fs_log("* amiga cd32 gamepad\n");
if (strcmp(port->device, "MOUSE") == 0) {
fs_log("* cannot map mouse to cd32 gamepad\n");
}
else {
fs_log("* using device %s\n", port->device);
fs_emu_configure_joystick(port->device, "cd32",
g_joystick_mappings[i], 1, NULL, 0, true);
}
}
}
fs_uae_input_port *port0 = g_fs_uae_input_ports;
#if 0
int autoswitch = fs_config_get_boolean("joystick_port_0_autoswitch");
if (autoswitch == FS_CONFIG_NONE) {
autoswitch = 0;
}
if (!autoswitch) {
if (mouse_mapped_to_port == -1 && port0->mode != AMIGA_JOYPORT_NONE) {
// there is a device in port 0, but mouse is not use in either
// port
fs_log("additionally mapping mouse buttons to port 0\n");
fs_emu_configure_mouse("MOUSE", 0, 0, INPUTEVENT_JOY1_FIRE_BUTTON,
0, INPUTEVENT_JOY1_2ND_BUTTON, 0);
}
}
#endif
if (mouse_mapped_to_port == -1 && port0->mode == AMIGA_JOYPORT_DJOY) {
fs_log("additionally mapping mouse to port 0\n");
map_mouse("mouse", 0);
}
#if 0
if (autoswitch && !fs_emu_netplay_enabled()) {
// auto-select for other devices when not in netplay mode
if (mouse_mapped_to_port == -1) {
// FIXME: device "9" is a bit of a hack here, should promote
fs_emu_configure_mouse("MOUSE",
0, 0, INPUTEVENT_AMIGA_JOYPORT_0_DEVICE_9, 0, 0, 0);
}
int count;
fs_emu_input_device *input_device = fs_emu_get_input_devices(&count);
for (int i = 0; i < count; i++) {
//printf("---- %d %s\n", i, input_device->name);
//printf("usage: %d\n", input_device->usage);
if (input_device->usage) {
// this device is used, so we don't want auto-select for this
// device
input_device++;
continue;
}
if (strcmp(input_device->name, "KEYBOARD") == 0) {
continue;
}
int input_event = INPUTEVENT_AMIGA_JOYPORT_0_DEVICE_0 + i;
fs_emu_input_mapping mapping[] = {
{ "1", input_event },
{ NULL, 0 },
};
fs_emu_configure_joystick(input_device->name, "amiga",
mapping, 0, NULL, 0);
input_device++;
};
}
#endif
fs_emu_map_custom_actions();
}
static void set_video_mode()
{
int flags = SDL_WINDOW_OPENGL;
if (g_fs_emu_video_fullscreen_mode != FULLSCREEN_WINDOW &&
g_window_resizable) {
flags |= SDL_WINDOW_RESIZABLE;
}
int x = g_window_x, y = g_window_y;
int w = -1, h = -1;
// if (g_initial_input_grab) {
// flags |= SDL_WINDOW_INPUT_GRABBED;
// g_has_input_grab = 1;
// }
if (g_fs_emu_video_fullscreen == 1) {
w = g_fullscreen_width;
h = g_fullscreen_height;
//w = g_window_width;
//h = g_window_height;
if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_WINDOW) {
fs_log("using fullscreen window mode\n");
//x = 0;
//y = 0;
//w = g_fullscreen_width;
//h = g_fullscreen_height;
flags |= SDL_WINDOW_BORDERLESS;
FSEmuMonitor monitor;
fs_emu_monitor_get_by_index(g_display, &monitor);
x = monitor.rect.x;
y = monitor.rect.y;
w = monitor.rect.w;
h = monitor.rect.h;
}
else if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_DESKTOP) {
fs_log("using fullscreen desktop mode\n");
// the width and height will not be used for the fullscreen
// desktop mode, only for the window when toggling fullscreen
// state
#if 0
w = g_window_width;
h = g_window_height;
#else
FSEmuMonitor monitor;
fs_emu_monitor_get_by_index(g_display, &monitor);
x = monitor.rect.x;
y = monitor.rect.y;
w = monitor.rect.w;
h = monitor.rect.h;
#endif
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
else {
fs_log("using SDL_FULLSCREEN mode\n");
flags |= SDL_WINDOW_FULLSCREEN;
}
fs_log("setting (fullscreen) video mode %d %d\n", w, h);
}
else {
w = g_window_width;
h = g_window_height;
fs_log("using windowed mode\n");
//SDL_putenv("SDL_VIDEO_WINDOW_POS=");
fs_log("setting (windowed) video mode %d %d\n", w, h);
}
if (fs_config_get_boolean("window_border") == 0) {
fs_log("borderless window requested\n");
flags |= SDL_WINDOW_BORDERLESS;
}
#if 0
Uint8 data[] = "\0";
SDL_Cursor *cursor = SDL_CreateCursor(data, data, 8, 1, 0, 0);
SDL_SetCursor(cursor);
#endif
g_fs_ml_video_width = w;
g_fs_ml_video_height = h;
fs_log("[SDL] CreateWindow(x=%d, y=%d, w=%d, h=%d, flags=%d)\n",
x, y, w, h, flags);
g_fs_ml_window = SDL_CreateWindow(g_window_title, x, y, w, h, flags);
int assume_refresh_rate = fs_config_get_int("assume_refresh_rate");
if (assume_refresh_rate != FS_CONFIG_NONE) {
fs_log("[DISPLAY] Assuming host refresh rate: %d Hz (from config)\n",
assume_refresh_rate);
g_fs_emu_video_frame_rate_host = assume_refresh_rate;
} else {
SDL_DisplayMode mode;
if (SDL_GetWindowDisplayMode(g_fs_ml_window, &mode) == 0) {
g_fs_emu_video_frame_rate_host = mode.refresh_rate;
} else {
g_fs_emu_video_frame_rate_host = 0;
}
fs_log("[DISPLAY] Host refresh rate: %d Hz\n",
g_fs_emu_video_frame_rate_host);
}
if (g_fs_emu_video_frame_rate_host) {
g_fs_ml_target_frame_time = 1000000 / g_fs_emu_video_frame_rate_host;
}
g_fs_ml_context = SDL_GL_CreateContext(g_fs_ml_window);
#ifdef WITH_GLEW
static int glew_initialized = 0;
if (!glew_initialized) {
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "[GLEW] Error: %s\n", glewGetErrorString(err));
fs_emu_fatal("[GLEW] Error initializing glew");
}
fs_log("[GLEW] Version %s\n", glewGetString(GLEW_VERSION));
glew_initialized = 1;
}
#elif defined(WITH_GLAD)
static int glad_initialized = 0;
if (!glad_initialized) {
if (!gladLoadGLLoader((GLADloadproc) SDL_GL_GetProcAddress)) {
fs_emu_fatal("[GLAD] Failed to initialize OpenGL context");
}
glad_initialized = 1;
}
#endif
fs_ml_configure_window();
// FIXME: this can be removed
g_fs_ml_opengl_context_stamp++;
log_opengl_information();
}
void fs_ml_input_init() {
FS_ML_INIT_ONCE;
SDL_Init(SDL_INIT_JOYSTICK);
fs_log("fs_ml_input_init\n");
if (fs_config_get_boolean(OPTION_MOUSE_INTEGRATION) == 1) {
g_mouse_integration = 1;
}
g_cursor_mode = fs_config_get_boolean(OPTION_CURSOR);
if (fs_config_check_auto(OPTION_CURSOR, FS_CONFIG_AUTO)) {
if (fs_emu_mouse_integration()) {
g_cursor_mode = 0;
} else {
g_cursor_mode = -1;
}
}
g_input_queue = g_queue_new();
g_input_mutex = fs_mutex_create();
fs_log("calling fs_ml_video_init\n");
fs_ml_video_init();
int size = sizeof(fs_ml_input_device) * FS_ML_INPUT_DEVICES_MAX;
// allocate zeroed memory
g_fs_ml_input_devices = g_malloc0(size);
fs_ml_initialize_keymap();
int k = 0;
g_fs_ml_first_joystick_index = 0;
g_fs_ml_input_devices[k].type = FS_ML_KEYBOARD;
g_fs_ml_input_devices[k].index = k;
g_fs_ml_input_devices[k].name = g_strdup("KEYBOARD");
g_fs_ml_input_devices[k].alias = g_strdup("KEYBOARD");
k += 1;
g_fs_ml_input_device_count = k;
fs_ml_mouse_init();
k = g_fs_ml_input_device_count;
g_fs_ml_first_joystick_index = g_fs_ml_input_device_count;
int num_joysticks = SDL_NumJoysticks();
fs_log("num joystick devices: %d\n", num_joysticks);
if (SDL_WasInit(SDL_INIT_JOYSTICK) == 0) {
fs_log("WARNING: Joystick module not initialized\n");
}
for (int i = 0; i < num_joysticks; i++) {
if (k == FS_ML_INPUT_DEVICES_MAX) {
fs_log("WARNING: reached max num devices\n");
break;
}
SDL_Joystick *joystick = SDL_JoystickOpen(i);
#ifdef USE_SDL2
char* name = g_ascii_strup(SDL_JoystickName(joystick), -1);
#else
char* name = g_ascii_strup(SDL_JoystickName(i), -1);
#endif
name = g_strstrip(name);
if (name[0] == '\0') {
g_free(name);
name = g_ascii_strup("Unnamed", -1);
}
// fs_ml_input_unique_device_name either returns name, or frees it
// and return another name, so name must be malloced and owned by
// caller
name = fs_ml_input_unique_device_name(name);
g_fs_ml_input_devices[k].type = FS_ML_JOYSTICK;
g_fs_ml_input_devices[k].index = k;
g_fs_ml_input_devices[k].name = name;
if (i == 0) {
g_fs_ml_input_devices[k].alias = g_strdup("JOYSTICK");
}
else {
g_fs_ml_input_devices[k].alias = g_strdup_printf("JOYSTICK #%d",
i + 1);
}
g_fs_ml_input_devices[k].hats = SDL_JoystickNumHats(joystick);
g_fs_ml_input_devices[k].buttons = SDL_JoystickNumButtons(joystick);
g_fs_ml_input_devices[k].axes = SDL_JoystickNumAxes(joystick);
g_fs_ml_input_devices[k].balls = SDL_JoystickNumBalls(joystick);
fs_log("joystick device #%02d found: %s\n", i + 1, name);
fs_log("- %d buttons %d hats %d axes %d balls\n",
g_fs_ml_input_devices[k].buttons,
g_fs_ml_input_devices[k].hats,
g_fs_ml_input_devices[k].axes,
g_fs_ml_input_devices[k].balls);
k += 1;
}
g_fs_ml_input_device_count = k;
fs_ml_initialize_keymap();
}
void fs_uae_configure_hard_drives() {
static const char *ro_string = "ro";
static const char *rw_string = "rw";
const char *read_write = rw_string;
fs_emu_log("fs_uae_configure_hard_drives\n");
for(int i = 0; i < 10; i++) {
char *fs_uae_option = fs_strdup_printf("hard_drive_%d", i);
char *path = fs_config_get_string(fs_uae_option);
free(fs_uae_option);
if (path == NULL) {
continue;
}
if (path[0] == '\0') {
continue;
}
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_HD_PATHS);
if (!fs_path_exists(path)) {
char *msg = fs_strdup_printf("HD path \"%s\" does not exist",
path);
fs_emu_warning(msg);
free(msg);
continue;
}
int boot_priority = -i;
read_write = rw_string;
char *device = fs_strdup_printf("DH%d", i);
int virtual = 0;
if (fs_path_is_dir(path)) {
virtual = 1;
}
else if (fs_str_has_suffix(path, ".zip")) {
virtual = 1;
read_write = ro_string;
}
fs_uae_option = fs_strdup_printf("hard_drive_%d_read_only", i);
if (fs_config_get_boolean(fs_uae_option) == 1) {
read_write = ro_string;
}
free(fs_uae_option);
if (virtual) {
char *type = fs_strdup("dir");
int surfaces = 1;
int reserved = 2;
//char *hd_controller = g_strdup("ide0");
int sectors = 32;
int block_size = 512;
char *mount_name;
char *label_option_name = fs_strdup_printf(
"hard_drive_%d_label", i);
char *label_option = fs_config_get_string(label_option_name);
if (label_option) {
mount_name = label_option;
}
else {
mount_name = fs_path_get_basename(path);
}
fs_emu_log("hard drive mount: %s\n", path);
fs_emu_log("device: %s\n", device);
fs_emu_log("mount name: %s\n", mount_name);
fs_emu_log("read/write: %s\n", read_write);
fs_emu_log("boot priority: %d\n", boot_priority);
/*
char *option = fs_strdup_printf("uaehf%d", i);
char *value = fs_strdup_printf("%s,%s,%s:%s:%s,%d",
type, read_write, device, mount_name, path,
boot_priority);
amiga_set_option(option, value);
*/
char *option2 = fs_strdup("filesystem2");
char *value2 = fs_strdup_printf("%s,%s:%s:%s,%d",
read_write, device, mount_name, path,
boot_priority);
amiga_set_option(option2, value2);
free(option2);
free(value2);
// uaehf0=hdf,rw,DH0:path.hdf,32,1,2,512,0,,uae;
//free(option);
//free(value);
free(device);
free(type);
free(mount_name);
continue;
}
else if (fs_path_exists(path)) {
void fs_uae_configure_amiga_hardware() {
amiga_config *c = g_fs_uae_amiga_configs + g_fs_uae_amiga_config;
char *path;
fs_emu_log("fs_uae_configure_amiga_hardware\n");
fs_uae_load_rom_files(fs_uae_kickstarts_dir());
#ifdef NEW_ACCURACY_SYSTEM
g_accuracy = 1;
#endif
fs_emu_log("configuring \"%s\", accuracy=%d\n", c->name, g_accuracy);
amiga_quickstart(c->quickstart_model, c->quickstart_config, g_accuracy);
amiga_set_option("cachesize", "0");
if (c->cpu_model) {
amiga_set_option("cpu_model", c->cpu_model);
}
if (c->z3mem_size) {
amiga_set_int_option("z3mem_size", c->z3mem_size);
}
if (c->cpu_32bit_addressing) {
amiga_set_option("cpu_24bit_addressing", "false");
}
if (c->fast) {
amiga_set_option("cpu_speed", "max");
amiga_set_option("blitter_cycle_exact", "false");
amiga_set_option("cpu_cycle_exact", "false");
amiga_set_option("cpu_compatible", "false");
amiga_set_option("immediate_blits", "true");
}
//if (g_fs_uae_fastest_possible) {
amiga_set_cpu_idle(2);
//}
if (g_fs_uae_ntsc_mode) {
// FIXME: ciiatod on some Amiga models?
amiga_set_option("ntsc", "true");
}
path = fs_config_get_string("kickstart_file");
if (path) {
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_ROM_PATHS);
amiga_set_option("kickstart_rom_file", path);
free(path);
}
path = fs_config_get_string("kickstart_ext_file");
if (path) {
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_ROM_PATHS);
amiga_set_option("kickstart_ext_rom_file", path);
free(path);
}
configure_memory(c);
if (fs_config_get_boolean("bsdsocket_library") == 1) {
amiga_set_option("bsdsocket_emu", "yes");
}
amiga_enable_serial_port();
configure_accuracy(c);
/*
if (g_fs_uae_amiga_model == MODEL_A500) {
if (slow_memory || fast_memory || chip_memory > 512) {
fs_log("using A500 and memory expansions, "
"enabling real-time clock");
amiga_set_option("rtc", "MSM6242B");
}
}
*/
/*
char **keys = g_key_file_get_keys(g_fs_uae_config, "uae", NULL, NULL);
if (keys) {
for (char **key = keys; *key; key++) {
char *value = g_key_file_get_string(g_fs_uae_config, "uae",
*key, NULL);
if (value != NULL) {
amiga_set_option(*key, value);
free(value);
}
}
g_strfreev(keys);
}
*/
}
void fs_uae_configure_amiga_model() {
char *path;
fs_emu_log("fs_uae_configure_amiga_model\n");
fs_uae_init_configs();
//amiga_set_option("kickstart_rom_file", "aa:AROS");
if (fs_config_get_boolean("ntsc_mode") == 1) {
fs_emu_log("enabling NTSC mode (60Hz)\n");
g_fs_uae_ntsc_mode = 1;
fs_emu_set_video_frame_rate(60);
}
else {
fs_emu_log("using PAL mode (50Hz)\n");
fs_emu_set_video_frame_rate(50);
}
g_fs_uae_amiga_config = -1;
const char *config_model = fs_config_get_const_string("amiga_model");
if (config_model == NULL) {
config_model = fs_config_get_const_string("model");
}
if (config_model) {
int i = 0;
for (amiga_config* c = g_fs_uae_amiga_configs; c->id; c++, i++) {
if (fs_ascii_strcasecmp(config_model, c->id) == 0) {
fs_emu_log("config match for \"%s\"\n", c->id);
g_fs_uae_amiga_config = i;
break;
}
}
}
if (g_fs_uae_amiga_config == -1) {
fs_emu_log("WARNING: unknown amiga config specified, using A500\n");
g_fs_uae_amiga_config = CONFIG_A500;
}
amiga_config *c = g_fs_uae_amiga_configs + g_fs_uae_amiga_config;
g_fs_uae_amiga_model = c->model;
g_accuracy = fs_config_get_int_clamped("accuracy", -2, 1);
if (c->no_accuracy_adjustment) {
fs_emu_log("ignoring accuracy for this model\n");
g_accuracy = 1;
}
if (g_accuracy == FS_CONFIG_NONE) {
g_accuracy = 1;
}
if (g_accuracy <= c->fast_on_accuracy_level) {
fs_emu_log("this model / accuracy combination is a "
"\"fastest possibly\" mode\n");
g_fs_uae_fastest_possible = 1;
}
if (!fs_emu_get_title()) {
fs_emu_set_title(c->name);
}
if (!fs_emu_get_sub_title()) {
fs_emu_set_sub_title("FS-UAE");
}
}
void fs_uae_configure_menu() {
fs_emu_log("fs_uae_configure_menu\n");
fs_emu_menu_item *item;
fs_emu_menu *menu = fs_emu_menu_new();
fs_emu_menu_set_update_function(menu, update_main_menu);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Emulator Control"));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_HEADING);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Pause"));
fs_emu_menu_item_set_activate_function(item, pause_function);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Load State"));
fs_emu_menu_item_set_activate_function(item, load_states_menu_function);
if (fs_config_get_boolean("save_states") == 0) {
fs_emu_menu_item_set_enabled(item, 0);
}
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Save State"));
fs_emu_menu_item_set_activate_function(item, save_states_menu_function);
if (fs_config_get_boolean("save_states") == 0) {
fs_emu_menu_item_set_enabled(item, 0);
}
/*
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("More..."));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_enabled(item, 0);
*/
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Amiga Control"));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_HEADING);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Reset Amiga"));
fs_emu_menu_item_set_activate_function(item, reset_menu_function);
/*
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("More..."));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_enabled(item, 0);
*/
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Input Options"));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_HEADING);
add_input_item(menu, 1);
add_input_item(menu, 0);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("More..."));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
//fs_emu_menu_item_set_enabled(item, 0);
fs_emu_menu_item_set_activate_function(item, input_options_menu_function);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, _("Removable Media"));
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_HEADING);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, "");
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_idata(item, 0);
fs_emu_menu_item_set_activate_function(item, media_menu_function);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, "");
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_idata(item, 1);
fs_emu_menu_item_set_activate_function(item, media_menu_function);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, "");
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_idata(item, 2);
fs_emu_menu_item_set_activate_function(item, media_menu_function);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
fs_emu_menu_item_set_title(item, "");
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_MENU);
fs_emu_menu_item_set_idata(item, 3);
fs_emu_menu_item_set_activate_function(item, media_menu_function);
fs_emu_menu_set_current(menu);
}
static int load_config_file()
{
fs_log("load config file\n");
const char *msg = "checking config file %s\n";
char *data;
int size;
if (fs_data_file_content("META-INF/Config.fs-uae", &data, &size) == 0) {
fs_ini_file *ini_file = fs_ini_file_open_data(data, size);
if (ini_file == NULL) {
fs_log("error loading config file\n");
return 1;
}
fs_config_parse_ini_file(ini_file);
fs_ini_file_destroy(ini_file);
return 0;
}
//g_fs_uae_config = g_key_file_new();
if (g_fs_uae_config_file_path == NULL) {
char *path = g_build_filename(fs_uae_exe_dir(), "Config.fs-uae",
NULL);
fs_log(msg, path);
if (fs_path_exists(path)) {
g_fs_uae_config_file_path = path;
}
else {
free(path);
}
}
#ifdef MACOSX
if (g_fs_uae_config_file_path == NULL) {
char *path = g_build_filename(fs_uae_exe_dir(), "..", "..",
"Config.fs-uae", NULL);
fs_log(msg, path);
if (fs_path_exists(path)) {
g_fs_uae_config_file_path = path;
}
else {
free(path);
}
}
#endif
if (g_fs_uae_config_file_path == NULL) {
fs_log(msg, "Config.fs-uae");
if (fs_path_exists("Config.fs-uae")) {
g_fs_uae_config_file_path = "Config.fs-uae";
}
}
if (g_fs_uae_config_file_path == NULL) {
fs_log(msg, "fs-uae.conf");
if (fs_path_exists("fs-uae.conf")) {
g_fs_uae_config_file_path = "fs-uae.conf";
}
}
if (g_fs_uae_config_file_path == NULL) {
char *path = g_build_filename(fs_get_user_config_dir(),
"fs-uae", "fs-uae.conf", NULL);
fs_log(msg, path);
if (fs_path_exists(path)) {
g_fs_uae_config_file_path = path;
}
else {
free(path);
}
}
if (g_fs_uae_config_file_path == NULL) {
char *path = g_build_filename(fs_uae_configurations_dir(),
"Default.fs-uae", NULL);
fs_log(msg, path);
if (fs_path_exists(path)) {
g_fs_uae_config_file_path = path;
}
else {
free(path);
}
}
if (g_fs_uae_config_file_path) {
fs_log("loading config from %s\n", g_fs_uae_config_file_path);
fs_config_read_file(g_fs_uae_config_file_path, 0);
g_fs_uae_config_dir_path = g_path_get_dirname(
g_fs_uae_config_file_path);
}
#if 0
else {
if (fs_config_get_boolean("end_config") == 1) {
// do not warn in case end_config was specified via argv
}
else {
fs_log("No configuration file was found");
g_warn_about_missing_config_file = 1;
}
}
#endif
char *path = g_build_filename(fs_uae_configurations_dir(),
"Host.fs-uae", NULL);
fs_log(msg, path);
if (fs_path_exists(path)) {
fs_config_read_file(path, 0);
free(path);
}
return 0;
}
int fs_ml_video_create_window(const char *title)
{
fs_log("fs_ml_video_create_window\n");
g_window_title = g_strdup(title);
g_fs_ml_keyboard_input_grab = fs_config_get_boolean(
"keyboard_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
g_fs_ml_keyboard_input_grab = 1;
}
fs_log("keyboard input grab: %d\n", g_fs_ml_keyboard_input_grab);
static int initialized = 0;
SDL_SetHint(SDL_HINT_GRAB_KEYBOARD,
g_fs_ml_keyboard_input_grab ? "1" : "0");
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
#ifdef WINDOWS
SDL_SetHint(SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4, "1");
#endif
SDL_Init(SDL_INIT_VIDEO);
SDL_version cversion, lversion;
SDL_VERSION(&cversion);
SDL_GetVersion(&lversion);
fs_log("[SDL] Version %d.%d.%d (Compiled against %d.%d.%d)\n",
lversion.major, lversion.minor, lversion.patch,
cversion.major, cversion.minor, cversion.patch);
if (!initialized) {
int display_index = 0;
SDL_DisplayMode mode;
int error = SDL_GetCurrentDisplayMode(display_index, &mode);
if (error) {
fs_log("SDL_GetCurrentDisplayMode failed\n");
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Display Error",
"SDL_GetCurrentDisplayMode failed.", NULL);
exit(1);
}
fs_emu_monitor_init();
const char *mon = fs_config_get_const_string("monitor");
int mon_flag = -1;
if (mon == NULL) {
mon = "middle-left";
}
if (strcmp(mon, "left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_LEFT;
} else if (strcmp(mon, "middle-left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
} else if (strcmp(mon, "middle-right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_RIGHT;
} else if (strcmp(mon, "right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_RIGHT;
}
else {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
}
FSEmuMonitor monitor;
fs_emu_monitor_get_by_flag(mon_flag, &monitor);
fs_log("Monitor \"%s\" (flag %d) => index %d\n",
mon, mon_flag, monitor.index);
g_display = monitor.index;
g_fullscreen_width = fs_config_get_int("fullscreen_width");
if (g_fullscreen_width == FS_CONFIG_NONE) {
g_fullscreen_width = mode.w;
}
g_fullscreen_height = fs_config_get_int("fullscreen_height");
if (g_fullscreen_height == FS_CONFIG_NONE) {
g_fullscreen_height = mode.h;
}
if (g_fs_emu_video_fullscreen_mode_string == NULL) {
g_fs_emu_video_fullscreen_mode = -1;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"window") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_WINDOW;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"fullscreen") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"desktop") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
if (g_fs_emu_video_fullscreen_mode == -1) {
#ifdef MACOSX
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#else
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#endif
fs_log("[SDL] Defaulting to fullscreen_mode = desktop for SDL 2\n");
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
initialized = 1;
}
if (g_fs_ml_video_sync) {
g_fs_ml_vblank_sync = 1;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (g_fsaa) {
fs_log("setting FSAA samples to %d\n", g_fsaa);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, g_fsaa);
}
g_window_width = fs_config_get_int("window_width");
if (g_window_width == FS_CONFIG_NONE) {
g_window_width = 1920 / 2;
}
g_window_height = fs_config_get_int("window_height");
if (g_window_height == FS_CONFIG_NONE) {
g_window_height = 1080/ 2;
}
g_window_x = fs_config_get_int("window_x");
if (g_window_x == FS_CONFIG_NONE) {
g_window_x = SDL_WINDOWPOS_CENTERED;
}
g_window_y = fs_config_get_int("window_y");
if (g_window_y == FS_CONFIG_NONE) {
g_window_y = SDL_WINDOWPOS_CENTERED;
}
g_window_resizable = fs_config_get_boolean("window_resizable");
if (g_window_resizable == FS_CONFIG_NONE) {
g_window_resizable = 1;
}
g_fs_ml_automatic_input_grab = fs_config_get_boolean(
"automatic_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
if (fs_ml_mouse_integration()) {
g_fs_ml_automatic_input_grab = 0;
} else {
g_fs_ml_automatic_input_grab = 1;
}
}
fs_log("automatic input grab: %d\n", g_fs_ml_automatic_input_grab);
g_initial_input_grab = g_fs_ml_automatic_input_grab;
if (fs_config_get_boolean("initial_input_grab") == 1) {
g_initial_input_grab = 1;
}
else if (fs_config_get_boolean("initial_input_grab") == 0 ||
// deprecated names:
fs_config_get_boolean("input_grab") == 0 ||
fs_config_get_boolean("grab_input") == 0) {
g_initial_input_grab = 0;
}
set_video_mode();
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** Setting swap interval to 1 ***\n");
if (SDL_GL_SetSwapInterval(1) != 0) {
fs_emu_warning("SDL_GL_SetSwapInterval(1) failed");
}
}
else {
fs_emu_log("*** Setting swap interval to 0 ***\n");
SDL_GL_SetSwapInterval(0);
}
fs_log("initial input grab: %d\n", g_initial_input_grab);
if (g_initial_input_grab && !g_has_input_grab) {
fs_ml_set_input_grab(true);
}
fs_ml_show_cursor(0, 1);
/* This looks a bit peculiar, but it helps to show the window in
* fullscreen mode as soon as possible to reduce flickering,
at least under GNOME 3. */
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
int64_t start_time = fs_emu_monotonic_time();
SDL_Event event;
while (fs_emu_monotonic_time() - start_time < 100 * 1000) {
SDL_WaitEventTimeout(&event, 10);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
}
// this function must be called from the video thread
fs_log("init_opengl\n");
fse_init_video_opengl();
SDL_StartTextInput();
#ifdef WINDOWS
if (!fs_config_false(OPTION_RAW_INPUT)) {
fs_ml_init_raw_input();
}
#endif
fs_log("create windows is done\n");
return 1;
}
int main(int argc, char *argv[])
{
fs_uae_argc = argc;
fs_uae_argv = argv;
fs_set_argv(argc, argv);
#ifdef WITH_CEF
cef_init(argc, argv);
#endif
char **arg;
arg = argv + 1;
while (arg && *arg) {
if (strcmp(*arg, "--list-joysticks") == 0) {
list_joysticks();
exit(0);
} else if (strcmp(*arg, "--list-devices") == 0) {
list_joysticks();
exit(0);
} else if (strcmp(*arg, "--version") == 0) {
printf("%s\n", PACKAGE_VERSION);
exit(0);
} else if (strcmp(*arg, "--help") == 0) {
printf(COPYRIGHT_NOTICE, PACKAGE_VERSION, OS_NAME_2, ARCH_NAME_2);
printf(EXTRA_HELP_TEXT);
exit(0);
}
arg++;
}
fs_init();
int error = fs_data_init("fs-uae", "fs-uae.dat");
if (error) {
printf("WARNING: error (%d) loading fs-uae.dat\n", error);
}
fs_set_prgname("fs-uae");
fs_set_application_name("Amiga Emulator");
amiga_set_log_function(log_to_libfsemu);
//result = parse_options(argc, argv);
printf(COPYRIGHT_NOTICE, PACKAGE_VERSION, OS_NAME_2, ARCH_NAME_2);
fs_log(COPYRIGHT_NOTICE, PACKAGE_VERSION, OS_NAME_2, ARCH_NAME_2);
char *current_dir = g_get_current_dir();
fs_log("current directory is %s\n", current_dir);
g_free(current_dir);
amiga_init();
#if 0
// FIXME: disabling fullscreen spaces must be done before
// SDL_INIT_VIDEO, but we need to check config to see if this should
// be done, and we initialize SDL early to check for config file
// (catch 22)...
// FIXME: check fullscreen_spaces option
SDL_SetHint(SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, "0");
#endif
#ifdef MACOSX
SDL_Init(SDL_INIT_EVERYTHING);
SDL_PumpEvents();
SDL_Event event;
fs_log("OS X: Check for pending SDL_DROPFILE event\n");
while (SDL_PollEvent(&event)) {
fs_log("Got SDL event 0x%x\n", event.type);
if (event.type == SDL_DROPFILE) {
if (event.drop.file != NULL) {
g_fs_uae_config_file_path = strdup(event.drop.file);
}
SDL_free(event.drop.file);
}
}
#endif
// skip first entry
arg = argv + 1;
if (g_fs_uae_config_file_path == NULL) {
while (arg && *arg) {
const gchar *test_path = *arg;
if (test_path && fs_path_exists(test_path)) {
if (check_extension(test_path, ".fs-uae")) {
g_fs_uae_config_file_path = g_strdup(test_path);
} else if (check_extension(test_path, ".conf")) {
g_fs_uae_config_file_path = g_strdup(test_path);
} else if (check_extension(test_path, ".adf")) {
g_fs_uae_disk_file_path = g_strdup(test_path);
} else if (check_extension(test_path, ".ipf")) {
g_fs_uae_disk_file_path = g_strdup(test_path);
} else if (check_extension(test_path, ".dms")) {
g_fs_uae_disk_file_path = g_strdup(test_path);
}
}
arg++;
}
}
/* Parse options first, in case base_dir, logging options etc is
* specified on the command line. */
fs_config_parse_options(argc - 1, argv + 1);
fs_log("\n");
fs_log(LOG_LINE);
fs_log("libfsemu init\n");
fs_log(LOG_LINE);
fs_log("\n");
fs_emu_path_set_expand_function(fs_uae_expand_path);
fs_emu_init_overlays(overlay_names);
fs_emu_init();
// then load the config file
load_config_file();
init_i18n();
if (g_fs_uae_disk_file_path) {
fs_config_set_string(OPTION_FLOPPY_DRIVE_0, g_fs_uae_disk_file_path);
g_warn_about_missing_config_file = 0;
}
if (g_warn_about_missing_config_file) {
fs_emu_warning(_("No configuration file was found"));
}
fs_log("\n");
fs_log(LOG_LINE);
fs_log("fs-uae init\n");
fs_log(LOG_LINE);
fs_log("\n");
configure_logging(fs_config_get_const_string("log"));
fs_emu_set_state_check_function(amiga_get_state_checksum);
fs_emu_set_rand_check_function(amiga_get_rand_checksum);
// force creation of some recommended default directories
fs_uae_kickstarts_dir();
fs_uae_configurations_dir();
fs_uae_init_path_resolver();
fs_uae_plugins_init();
// must be called early, before fs_emu_init -affects video output
fs_uae_configure_amiga_model();
// force creation of state directories
//fs_uae_flash_memory_dir();
//fs_uae_save_states_dir();
//fs_uae_floppy_overlays_dir();
fs_uae_state_dir();
const char *controllers_dir = fs_uae_controllers_dir();
if (controllers_dir) {
fs_emu_set_controllers_dir(controllers_dir);
}
const char *logs_dir = fs_uae_logs_dir();
if (logs_dir) {
char *log_file;
log_file = g_build_filename(logs_dir, "FS-UAE.log", NULL);
if (fs_path_exists(log_file)) {
g_unlink(log_file);
}
g_free(log_file);
log_file = g_build_filename(logs_dir, "FS-UAE.log.txt", NULL);
if (fs_path_exists(log_file)) {
g_unlink(log_file);
}
g_free(log_file);
log_file = g_build_filename(logs_dir, "Emulator.log.txt", NULL);
if (fs_path_exists(log_file)) {
g_unlink(log_file);
}
g_free(log_file);
log_file = g_build_filename(logs_dir, "fs-uae.log.txt", NULL);
fs_config_set_log_file(log_file);
g_free(log_file);
}
fs_config_set_string_if_unset("themes_dir", fs_uae_themes_dir());
fs_emu_set_pause_function(pause_function);
//fs_uae_init_input();
fs_emu_init_2(FS_EMU_INIT_EVERYTHING);
// we initialize the recording module either it is used or not, so it
// can delete state-specific recordings (if necessary) when states are
// saved
fs_uae_init_recording();
int deterministic_mode = 0;
const char* record_file = fs_config_get_const_string("record");
if (record_file) {
fs_log("record file specified: %s, forcing deterministic mode\n",
record_file);
deterministic_mode = 1;
fs_uae_enable_recording(record_file);
} else {
fs_log("not running in record mode\n");
}
if (fs_emu_netplay_enabled() ||
fs_config_get_boolean(OPTION_DETERMINISTIC) == 1) {
deterministic_mode = 1;
}
if (deterministic_mode) {
amiga_set_deterministic_mode();
}
if (logs_dir) {
if (fs_emu_netplay_enabled()) {
char *sync_log_file = g_build_filename(logs_dir,
"Synchronization.log", NULL);
amiga_set_synchronization_log_file(sync_log_file);
free(sync_log_file);
}
}
#ifdef FS_EMU_DRIVERS
fs_emu_audio_stream_options **options = fs_emu_audio_alloc_stream_options(2);
options[0]->frequency = fs_emu_audio_output_frequency();
/* 12 * 2352 is CDDA_BUFFERS * 2352 (blkdev_cdimage.cpp) */
options[1]->buffer_size = 12 * 2352;
// begin playing with only one buffer queued
options[1]->min_buffers = 1;
fs_emu_audio_configure(options);
amiga_set_audio_buffer_size(options[0]->buffer_size);
fs_emu_audio_free_stream_options(options);
#else
// this stream is for paula output and drive clicks
// FIXME: could mix drive clicks in its own stream instead, -might
// give higher quality mixing
fs_emu_audio_stream_options options;
options.struct_size = sizeof(fs_emu_audio_stream_options);
fs_emu_init_audio_stream_options(&options);
options.frequency = fs_emu_audio_output_frequency();
fs_emu_init_audio_stream(0, &options);
amiga_set_audio_buffer_size(options.buffer_size);
// this stream is for CD audio output (CDTV/CD32)
fs_emu_init_audio_stream_options(&options);
// 12 * 2352 is CDDA_BUFFERS * 2352 (blkdev_cdimage.cpp)
options.buffer_size = 12 * 2352;
// begin playing with only one buffer queued
options.min_buffers = 1;
fs_emu_init_audio_stream(1, &options);
#endif
amiga_set_audio_callback(audio_callback_function);
amiga_set_cd_audio_callback(audio_callback_function);
amiga_set_event_function(event_handler);
amiga_set_led_function(led_function);
amiga_on_update_leds(on_update_leds);
amiga_set_media_function(media_function);
amiga_set_init_function(on_init);
if (fs_config_get_boolean(OPTION_JIT_COMPILER) == 1) {
amiga_init_jit_compiler();
}
#ifdef WITH_LUA
amiga_init_lua(fs_emu_acquire_lua, fs_emu_release_lua);
amiga_init_lua_state(fs_emu_get_lua_state());
fs_uae_init_lua_state(fs_emu_get_lua_state());
#endif
if (fs_emu_get_video_format() == FS_EMU_VIDEO_FORMAT_RGBA) {
amiga_set_video_format(AMIGA_VIDEO_FORMAT_RGBA);
} else if (fs_emu_get_video_format() == FS_EMU_VIDEO_FORMAT_BGRA) {
amiga_set_video_format(AMIGA_VIDEO_FORMAT_BGRA);
} else if (fs_emu_get_video_format() == FS_EMU_VIDEO_FORMAT_R5G6B5) {
amiga_set_video_format(AMIGA_VIDEO_FORMAT_R5G6B5);
} else if (fs_emu_get_video_format() == FS_EMU_VIDEO_FORMAT_R5G5B5A1) {
amiga_set_video_format(AMIGA_VIDEO_FORMAT_R5G5B5A1);
} else {
fs_emu_warning("Unsupported video format requested");
}
amiga_add_rtg_resolution(672, 540);
amiga_add_rtg_resolution(960, 540);
amiga_add_rtg_resolution(672 * 2, 540 * 2);
amiga_add_rtg_resolution(fs_emu_get_windowed_width(),
fs_emu_get_windowed_height());
amiga_add_rtg_resolution(fs_emu_get_fullscreen_width(),
fs_emu_get_fullscreen_height());
fs_uae_init_video();
//fs_uae_init_keyboard();
fs_uae_init_mouse();
fs_uae_configure_menu();
fs_emu_run(main_function);
fs_log("fs-uae shutting down, fs_emu_run returned\n");
if (g_rmdir(fs_uae_state_dir()) == 0) {
fs_log("state dir %s was removed because it was empty\n",
fs_uae_state_dir());
}
else {
fs_log("state dir %s was not removed (non-empty)\n",
fs_uae_state_dir());
}
fs_log("end of main function\n");
cleanup_old_files();
#ifdef WITH_CEF
cef_destroy();
#endif
return 0;
}
void fs_emu_video_init_options(void) {
//int auto_sync_mode = 1;
//int sync_to_vblank = 1;
//int sync_with_emu = 0;
char *sync_mode_str = NULL;
int fsaa = fs_config_get_int_clamped("fsaa", 0, 4);
if (fsaa != FS_CONFIG_NONE) {
fs_log("setting full-scene anti-aliasing (FSAA) to %dx%d\n",
fsaa, fsaa);
fs_ml_set_video_fsaa(fsaa);
}
else {
fs_log("full-scene anti-aliasing is not requested\n");
}
fs_ml_video_mode mode;
memset(&mode, 0, sizeof(fs_ml_video_mode));
if (fs_ml_video_mode_get_current(&mode) == 0) {
fs_log("current display mode is %dx%d @ %d Hz\n", mode.width,
mode.height, mode.fps);
int assume_refresh_rate = fs_config_get_int("assume_refresh_rate");
if (assume_refresh_rate != FS_CONFIG_NONE) {
fs_log("assuming host refresh rate: %d Hz (from config)\n",
assume_refresh_rate);
g_fs_emu_video_frame_rate_host = assume_refresh_rate;
}
else {
g_fs_emu_video_frame_rate_host = mode.fps;
}
}
else {
fs_log("could not get display mode\n");
}
fs_log("checking video sync mode\n");
sync_mode_str = fs_config_get_string("video_sync");
if (!sync_mode_str) {
// compatibility key, FIXME: remove when FS-UAE translates compat
// option names when loading config.
sync_mode_str = fs_config_get_string("sync");
}
if (sync_mode_str) {
if (g_ascii_strcasecmp(sync_mode_str, "auto") == 0) {
g_fs_emu_video_sync_to_vblank = 1;
g_fs_emu_video_allow_full_sync = 1;
}
else if (g_ascii_strcasecmp(sync_mode_str, "1") == 0) {
// shortcut option, nice from command line (e.g. --video-sync)
g_fs_emu_video_sync_to_vblank = 1;
g_fs_emu_video_allow_full_sync = 1;
}
else if (g_ascii_strcasecmp(sync_mode_str, "full") == 0) {
// old compatibility option
g_fs_emu_video_sync_to_vblank = 1;
g_fs_emu_video_allow_full_sync = 1;
}
else if (g_ascii_strcasecmp(sync_mode_str, "0") == 0) {
// shortcut option, nice from command line (e.g. --no-video-sync)
g_fs_emu_video_sync_to_vblank = 0;
g_fs_emu_video_allow_full_sync = 0;
}
else if (g_ascii_strcasecmp(sync_mode_str, "off") == 0) {
//g_fs_emu_video_sync_to_vblank = 0;
//g_fs_emu_video_allow_full_sync = 0;
}
else if (g_ascii_strcasecmp(sync_mode_str, "vblank") == 0) {
g_fs_emu_video_sync_to_vblank = 1;
}
else {
fs_log("WARNING: invalid value for video-sync: %s\n",
sync_mode_str);
}
free(sync_mode_str);
}
else {
//fs_log("not specified: using automatic video sync mode\n");
fs_log("not specified: no video sync\n");
//g_fs_emu_video_sync_to_vblank = 0;
//g_fs_emu_video_allow_full_sync = 0;
}
/*
if (auto_sync_mode) {
fs_log("auto sync mode is enabled\n");
if (frame_rate && frame_rate == mode.fps) {
fs_log("frame rate (%d) equals screen refresh (%d)\n",
frame_rate, mode.fps);
sync_to_vblank = 1;
sync_with_emu = 1;
}
else {
fs_log("frame rate (%d) does not equal screen refresh (%d)\n",
frame_rate, mode.fps);
sync_to_vblank = 1;
}
}
*/
if (fs_emu_netplay_enabled()) {
fs_log("netplay is enabled, disabling full video/emulator sync\n");
g_fs_emu_video_allow_full_sync = 0;
//sync_with_emu = 0;
//sync_to_vblank = 0;
}
if (fs_config_get_boolean("benchmark") != FS_CONFIG_NONE) {
fs_log("benchmarking enable, disabling video sync\n");
g_fs_emu_video_sync_to_vblank = 0;
//sync_with_emu = 0;
g_fs_emu_benchmarking = 1;
g_fs_ml_benchmarking = 1;
g_fs_emu_video_allow_full_sync = 0;
}
//if (sync_with_emu && !g_fs_emu_full_sync_allowed) {
// FIXME: check where g_fs_emu_full_sync_allowed is used
if (!g_fs_emu_full_sync_allowed) {
fs_log("full video/emu sync is not allowed in this mode\n");
//sync_with_emu = 0;
g_fs_emu_video_allow_full_sync = 0;
}
/*
if (sync_with_emu) {
fs_log("will sync emulation and video with vblank\n");
fs_ml_video_sync_enable();
if (frame_rate && mode.fps) {
double pitch = (1.0 * mode.fps) / frame_rate;
fs_log("changing audio pitch to %0.2f based on frame rates\n",
pitch);
fs_emu_audio_set_default_pitch(pitch);
}
}
else if (sync_to_vblank) {
fs_log("will sync video output only to vblank (no tearing)\n");
fs_ml_vblank_sync_enable();
}
else {
fs_log("no video sync\n");
}
*/
if (g_fs_emu_video_sync_to_vblank) {
fs_log("will sync video updates to vblank\n");
fs_ml_vblank_sync_enable();
}
else {
fs_log("no video sync (using timers only)\n");
}
if (fs_config_get_boolean("disable_aspect_correction") == 1) {
g_fs_emu_disable_aspect_correction = 1;
}
else if (fs_config_get_boolean("keep_aspect") == 1) {
fs_emu_video_set_aspect_correction(1);
}
// the default texture format is RGB, set here because some video
// formats implicitly changes the default texture format
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB;
const char *s = fs_config_get_const_string("video_format");
if (s) {
if (g_ascii_strcasecmp(s, "bgra") == 0) {
fs_log("using video format BGRA\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_BGRA;
g_fs_emu_video_bpp = 4;
}
else if (g_ascii_strcasecmp(s, "rgba") == 0) {
fs_log("using video format RGBA\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_RGBA;
g_fs_emu_video_bpp = 4;
}
else if (g_ascii_strcasecmp(s, "rgb") == 0) {
fs_log("using video format RGB\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_RGB;
g_fs_emu_video_bpp = 3;
}
else if (g_ascii_strcasecmp(s, "rgb565") == 0) {
fs_log("using video format RGB565\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_R5G6B5;
g_fs_emu_video_bpp = 2;
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB5;
}
else if (g_ascii_strcasecmp(s, "rgba5551") == 0) {
fs_log("using video format RGBA5551\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_R5G5B5A1;
g_fs_emu_video_bpp = 2;
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB5_A1;
}
else {
fs_emu_warning("Unknown video format");
}
}
if (!g_fs_emu_video_format) {
fs_log("using default video format BGRA\n");
g_fs_emu_video_format = FS_EMU_VIDEO_FORMAT_BGRA;
g_fs_emu_video_bpp = 4;
}
s = fs_config_get_const_string("texture_format");
if (s) {
if (g_ascii_strcasecmp(s, "rgb") == 0) {
fs_log("using texture format RGB\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB;
}
else if (g_ascii_strcasecmp(s, "rgb8") == 0) {
fs_log("using texture format RGB8\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB8;
}
else if (g_ascii_strcasecmp(s, "rgba") == 0) {
fs_log("using texture format RGBA\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGBA;
}
else if (g_ascii_strcasecmp(s, "rgba8") == 0) {
fs_log("using texture format RGBA8\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGBA8;
}
else if (g_ascii_strcasecmp(s, "rgb5") == 0) {
fs_log("using texture format RGB5\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB5;
}
else if (g_ascii_strcasecmp(s, "rgb5_a1") == 0) {
fs_log("using texture format RGB5_A1\n");
g_fs_emu_texture_format = FS_EMU_TEXTURE_FORMAT_RGB5_A1;
}
else {
fs_emu_warning("Unknown texture format (using default)");
}
}
else {
fs_log("using default texture format\n");
}
double dval;
if (fs_config_get_boolean("scanlines") == 1) {
g_fs_emu_scanlines = 1;
}
dval = fs_config_get_double_clamped("scanlines_light", 0, 100);
if (dval != FS_CONFIG_NONE) {
g_fs_emu_scanlines_light = 255.0 * dval / 100.0;
}
dval = fs_config_get_double_clamped("scanlines_dark", 0, 100);
if (dval != FS_CONFIG_NONE) {
g_fs_emu_scanlines_dark = 255.0 * dval / 100.0;
}
}
static void configure_joystick_port(
int port, const char *value, const char *port_name, const char *joy_dev)
{
fs_emu_log("configuring joystick port %d (%s)\n", port, value);
fs_uae_input_port *p = g_fs_uae_input_ports + port;
const char *auto_type = "amiga";
int auto_mode = AMIGA_JOYPORT_DJOY;
if (g_fs_uae_amiga_model == MODEL_CD32) {
auto_type = "cd32";
auto_mode = AMIGA_JOYPORT_CD32JOY;
}
char *key = g_strdup_printf("joystick_port_%d_mode", port);
const char *mode_string = fs_config_get_const_string(key);
free(key);
if (g_ascii_strcasecmp(value, "nothing") == 0
|| g_ascii_strcasecmp(value, "none") == 0) {
fs_emu_log("nothing connected to port\n");
strcpy(p->device, "");
p->new_mode = AMIGA_JOYPORT_NONE;
} else if (g_ascii_strcasecmp(value, "auto") == 0 && port < 2) {
if (port == 0) {
if (!mode_string
|| g_ascii_strcasecmp(mode_string, "mouse") == 0) {
p->new_mode = AMIGA_JOYPORT_MOUSE;
strcpy(p->device, "MOUSE");
} else if (g_ascii_strcasecmp(mode_string, "joystick") == 0) {
auto_joystick(p, port, AMIGA_JOYPORT_DJOY, "amiga");
} else if (g_ascii_strcasecmp(mode_string, "cd32 gamepad") == 0) {
auto_joystick(p, port, AMIGA_JOYPORT_CD32JOY, "cd32");
}
} else {
auto_joystick(p, port, auto_mode, auto_type);
#if 0
fs_emu_log("trying to auto-configure joystick 1 in port 1\n");
p->new_mode = auto_mode;
int result = fs_emu_configure_joystick("JOYSTICK", auto_type,
g_joystick_mappings[port], 1,
g_fs_uae_input_ports[port].device, MAX_DEVICE_NAME_LEN);
if (!result) {
fs_emu_log("could not auto-configure joystick 1, "
"using keyboard emulation\n");
strcpy(p->device, "KEYBOARD");
}
#endif
}
} else if (g_ascii_strcasecmp(value, "dummy mouse") == 0) {
p->new_mode = AMIGA_JOYPORT_MOUSE;
} else if (g_ascii_strcasecmp(value, "dummy joystick") == 0) {
p->new_mode = AMIGA_JOYPORT_DJOY;
} else if (g_ascii_strcasecmp(value, "mouse") == 0) {
strcpy(p->device, "MOUSE");
p->new_mode = AMIGA_JOYPORT_MOUSE;
}
// deprecated
else if (g_ascii_strcasecmp(value, "amiga_mouse") == 0) {
p->new_mode = AMIGA_JOYPORT_MOUSE;
}
// deprecated
else if (g_ascii_strcasecmp(value, "amiga_joystick") == 0) {
p->new_mode = AMIGA_JOYPORT_DJOY;
} else {
p->new_mode = auto_mode;
fs_emu_configure_joystick(value, auto_type,
g_joystick_mappings[port], 1,
p->device, MAX_DEVICE_NAME_LEN, false);
}
if (mode_string) {
char *mode_lower = g_ascii_strdown(mode_string, -1);
if (strcmp(mode_lower, "joystick") == 0) {
p->new_mode = AMIGA_JOYPORT_DJOY;
} else if (strcmp(mode_lower, "mouse") == 0) {
p->new_mode = AMIGA_JOYPORT_MOUSE;
} else if (strcmp(mode_lower, "cd32 gamepad") == 0) {
p->new_mode = AMIGA_JOYPORT_CD32JOY;
} else if (strcmp(mode_lower, "nothing") == 0) {
p->new_mode = AMIGA_JOYPORT_NONE;
} else if (strcmp(mode_lower, "none") == 0) {
p->new_mode = AMIGA_JOYPORT_NONE;
} else if (strcmp(mode_lower, "custom") == 0) {
// FIXME: custom is not fully implemented as its own type
p->new_mode = AMIGA_JOYPORT_DJOY;
} else {
fs_log("unknown joystick port mode: %s\n", mode_lower);
}
free(mode_lower);
}
if (port < 4) {
// port 4 is "custom joystick"
key = g_strdup_printf("joystick_port_%d_autofire", port);
if (fs_config_get_boolean(key) == 1) {
p->new_autofire_mode = 1;
p->autofire_mode = 1;
amiga_set_joystick_port_autofire(port, 1);
}
free(key);
} else {
/* This is a fake joystick, can be used to map keyboard pressed
* for example, mode is not set throught input actions, since
* this need not be synchronized in net play. */
p->mode = p->new_mode;
}
}
void fs_uae_configure_graphics_card(amiga_config *c)
{
const char *card = NULL;
int memory = 0;
bool found = false;
if (fs_config_get_const_string(OPTION_GRAPHICS_CARD)) {
card = fs_config_get_const_string(OPTION_GRAPHICS_CARD);
} else {
int uaegfx_card = fs_config_get_boolean(OPTION_UAEGFX_CARD);
if (uaegfx_card != FS_CONFIG_NONE) {
fs_log("DEPRECATED: uaegfx_card is deprecated, use graphics_card "
"instead\n");
if (uaegfx_card == 1) {
if (!c->allow_z3_memory) {
fs_emu_warning(_("Option uaegfx.card needs a CPU with "
"32-bit addressing"));
} else {
card = "ZorroIII";
memory = 32;
found = true;
}
}
}
}
if (card == NULL) {
/* For example A4000/OS4 defaults to picasso-iv-z3 */
card = cfg->default_graphics_card;
}
CHECK_CARD("none", NULL, 0, NULL, 0)
CHECK_CARD("uaegfx", "ZorroII", 8, "ZorroIII", 512)
CHECK_CARD("picasso-ii", "PicassoII", 2, NULL, 0)
CHECK_CARD("picasso-ii+", "PicassoII+", 2, NULL, 0)
CHECK_CARD("picasso-iv", "PicassoIV_Z2", 4, "PicassoIV_Z3", 4)
if (card && !found) {
fs_emu_warning("Unsupported graphics card: %s\n", card);
}
if (fs_config_get_const_string(OPTION_GRAPHICS_CARD_MEMORY)) {
memory = fs_uae_read_memory_option(OPTION_GRAPHICS_CARD_MEMORY);
memory /= 1024;
fs_log("CONFIG: Overriding graphics card memory: %d MB\n", memory);
}
if (card != NULL) {
if (memory != 0) {
amiga_set_option("gfxcard_type", card);
amiga_set_int_option("gfxcard_size", memory);
}
}
char *path = fs_config_get_string(OPTION_GRAPHICS_CARD_ROM);
if (path) {
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_ROM_PATHS);
amiga_set_option("picassoiv_rom_file", path);
g_free(path);
}
}
int fs_ml_video_create_window(const char *title) {
fs_log("fs_ml_video_create_window\n");
g_window_title = g_strdup(title);
static int initialized = 0;
SDL_Init(SDL_INIT_VIDEO);
#ifdef HAVE_GLES
if (!EGL_Open())
exit(1);
#endif
if (!initialized) {
const SDL_VideoInfo* info = SDL_GetVideoInfo();
g_fullscreen_width = fs_config_get_int("fullscreen_width");
if (g_fullscreen_width == FS_CONFIG_NONE) {
g_fullscreen_width = info->current_w;
}
g_fullscreen_height = fs_config_get_int("fullscreen_height");
if (g_fullscreen_height == FS_CONFIG_NONE) {
g_fullscreen_height = info->current_h;
}
if (g_fs_emu_video_fullscreen_mode == NULL) {
g_fs_emu_video_fullscreen_window = -1;
}
else if (g_strcasecmp(g_fs_emu_video_fullscreen_mode,
"window") == 0) {
g_fs_emu_video_fullscreen_window = 1;
}
else if (g_strcasecmp(g_fs_emu_video_fullscreen_mode,
"fullscreen") == 0) {
g_fs_emu_video_fullscreen_window = 0;
}
if (g_fs_emu_video_fullscreen_window == -1) {
#ifdef MACOSX
g_fs_emu_video_fullscreen_window = 0;
#else
g_fs_emu_video_fullscreen_window = 0;
#endif
}
initialized = 1;
}
if (g_fs_ml_video_sync) {
g_fs_ml_vblank_sync = 1;
}
#ifndef HAVE_GLES
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** SDL_GL_SWAP_CONTROL is enabled ***\n");
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
}
else {
fs_emu_log("*** SDL_GL_SWAP_CONTROL is disabled ***\n");
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 0);
}
if (g_fsaa) {
fs_log("setting FSAA samples to %d\n", g_fsaa);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, g_fsaa);
}
#endif
g_window_width = fs_config_get_int("window_width");
if (g_window_width == FS_CONFIG_NONE) {
g_window_width = 1920 / 2;
}
g_window_height = fs_config_get_int("window_height");
if (g_window_height == FS_CONFIG_NONE) {
g_window_height = 1080/ 2;
}
g_window_resizable = fs_config_get_boolean("window_resizable");
if (g_window_resizable == FS_CONFIG_NONE) {
g_window_resizable = 1;
}
set_video_mode();
#ifdef HAVE_GLES
EGL_Init();
#endif
// we display a black frame as soon as possible (to reduce flickering on
// startup)
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
fs_gl_finish();
SDL_WM_SetCaption(g_window_title, g_get_application_name());
if (fs_config_get_boolean("grab_input") != 0) {
fs_ml_grab_input(1, 1);
}
fs_ml_show_cursor(0, 1);
// this function must be called from the video thread
fs_log("init_opengl\n");
fs_emu_video_init_opengl();
#ifdef WINDOWS
fs_ml_init_raw_input();
#else
// enable keysym to unicode char translation
SDL_EnableUNICODE(1);
#endif
fs_log("create windows is done\n");
return 1;
}
int fs_ml_video_create_window(const char *title)
{
fs_log("fs_ml_video_create_window\n");
g_window_title = g_strdup(title);
g_fs_ml_keyboard_input_grab = fs_config_get_boolean(
"keyboard_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
g_fs_ml_keyboard_input_grab = 1;
}
fs_log("keyboard input grab: %d\n", g_fs_ml_keyboard_input_grab);
static int initialized = 0;
SDL_SetHint(SDL_HINT_GRAB_KEYBOARD,
g_fs_ml_keyboard_input_grab ? "1" : "0");
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
SDL_Init(SDL_INIT_VIDEO);
SDL_version version;
SDL_VERSION(&version);
fs_log("FS-UAE was compiled for SDL %d.%d.%d\n",
version.major, version.minor, version.patch);
if (!initialized) {
int display_index = 0;
SDL_DisplayMode mode;
int error = SDL_GetCurrentDisplayMode(display_index, &mode);
if (error) {
fs_log("SDL_GetCurrentDisplayMode failed\n");
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Display Error",
"SDL_GetCurrentDisplayMode failed.", NULL);
exit(1);
}
fs_emu_monitor_init();
const char *mon = fs_config_get_const_string("monitor");
int mon_flag = -1;
if (mon == NULL) {
mon = "middle-left";
}
if (strcmp(mon, "left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_LEFT;
} else if (strcmp(mon, "middle-left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
} else if (strcmp(mon, "middle-right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_RIGHT;
} else if (strcmp(mon, "right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_RIGHT;
}
else {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
}
FSEmuMonitor monitor;
fs_emu_monitor_get_by_flag(mon_flag, &monitor);
fs_log("Monitor \"%s\" (flag %d) => index %d\n",
mon, mon_flag, monitor.index);
g_display = monitor.index;
g_fullscreen_width = fs_config_get_int("fullscreen_width");
if (g_fullscreen_width == FS_CONFIG_NONE) {
g_fullscreen_width = mode.w;
}
g_fullscreen_height = fs_config_get_int("fullscreen_height");
if (g_fullscreen_height == FS_CONFIG_NONE) {
g_fullscreen_height = mode.h;
}
if (g_fs_emu_video_fullscreen_mode_string == NULL) {
g_fs_emu_video_fullscreen_mode = -1;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"window") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_WINDOW;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"fullscreen") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"desktop") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
if (g_fs_emu_video_fullscreen_mode == -1) {
#ifdef MACOSX
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#else
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#endif
fs_log("defaulting to fullscreen_mode = desktop for SDL2\n");
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
initialized = 1;
}
if (g_fs_ml_video_sync) {
g_fs_ml_vblank_sync = 1;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (g_fsaa) {
fs_log("setting FSAA samples to %d\n", g_fsaa);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, g_fsaa);
}
g_window_width = fs_config_get_int("window_width");
if (g_window_width == FS_CONFIG_NONE) {
g_window_width = 1920 / 2;
}
g_window_height = fs_config_get_int("window_height");
if (g_window_height == FS_CONFIG_NONE) {
g_window_height = 1080/ 2;
}
g_window_x = fs_config_get_int("window_x");
if (g_window_x == FS_CONFIG_NONE) {
g_window_x = SDL_WINDOWPOS_CENTERED;
}
g_window_y = fs_config_get_int("window_y");
if (g_window_y == FS_CONFIG_NONE) {
g_window_y = SDL_WINDOWPOS_CENTERED;
}
g_window_resizable = fs_config_get_boolean("window_resizable");
if (g_window_resizable == FS_CONFIG_NONE) {
g_window_resizable = 1;
}
g_fs_ml_automatic_input_grab = fs_config_get_boolean(
"automatic_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
if (fs_ml_mouse_integration()) {
g_fs_ml_automatic_input_grab = 0;
} else {
g_fs_ml_automatic_input_grab = 1;
}
}
fs_log("automatic input grab: %d\n", g_fs_ml_automatic_input_grab);
g_initial_input_grab = g_fs_ml_automatic_input_grab;
if (fs_config_get_boolean("initial_input_grab") == 1) {
g_initial_input_grab = 1;
}
else if (fs_config_get_boolean("initial_input_grab") == 0 ||
// deprecated names:
fs_config_get_boolean("input_grab") == 0 ||
fs_config_get_boolean("grab_input") == 0) {
g_initial_input_grab = 0;
}
set_video_mode();
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** Setting swap interval to 1 ***\n");
if (SDL_GL_SetSwapInterval(1) != 0) {
fs_emu_warning("SDL_GL_SetSwapInterval(1) failed");
}
}
else {
fs_emu_log("*** Setting swap interval to 0 ***\n");
SDL_GL_SetSwapInterval(0);
}
// we display a black frame as soon as possible (to reduce flickering on
// startup)
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
fs_gl_finish();
fs_log("initial input grab: %d\n", g_initial_input_grab);
if (g_initial_input_grab && !g_has_input_grab) {
fs_ml_set_input_grab(true);
}
fs_ml_show_cursor(0, 1);
// this function must be called from the video thread
fs_log("init_opengl\n");
fs_emu_video_init_opengl();
SDL_StartTextInput();
fs_log("create windows is done\n");
return 1;
}
