void fse_init_theme() { fs_log("THEME: Init\n"); fs_emu_theme_overlay* o = g_fs_emu_theme.overlays; o[FS_EMU_TOP_LEFT_OVERLAY].name = g_strdup("top_left_overlay"); o[FS_EMU_TOP_RIGHT_OVERLAY].name = g_strdup("top_right_overlay"); o[FS_EMU_TOP_RIGHT_OVERLAY].anchor = FS_EMU_ANCHOR_TOP_RIGHT; o[FS_EMU_BOTTOM_RIGHT_OVERLAY].name = g_strdup("bottom_right_overlay"); o[FS_EMU_BOTTOM_RIGHT_OVERLAY].anchor = FS_EMU_ANCHOR_BOTTOM_RIGHT; o[FS_EMU_BOTTOM_LEFT_OVERLAY].name = g_strdup("bottom_left_overlay"); o[FS_EMU_BOTTOM_LEFT_OVERLAY].anchor = FS_EMU_ANCHOR_BOTTOM_LEFT; o[FS_EMU_AUDIO_LED_OVERLAY].name = g_strdup("audio_led"); o[FS_EMU_FPS_LED_OVERLAY].name = g_strdup("fps_led"); o[FS_EMU_VSYNC_LED_OVERLAY].name = g_strdup("vsync_led"); o[FS_EMU_FPS_D0_OVERLAY].name = g_strdup("fps_d0"); o[FS_EMU_FPS_D1_OVERLAY].name = g_strdup("fps_d1"); const char *theme = fs_config_get_const_string("theme"); if (theme) { g_fs_emu_theme.name = g_strdup(theme); // first try to find the theme in the user's theme dir const char *themes_dir = fs_config_get_const_string("themes_dir"); if (themes_dir) { g_fs_emu_theme.path = g_build_filename(themes_dir, g_fs_emu_theme.name, NULL); if (!fs_path_exists(g_fs_emu_theme.path)) { free(g_fs_emu_theme.path); g_fs_emu_theme.path = NULL; } } // or by direct path lookup if (!g_fs_emu_theme.path) { if (fs_path_exists(theme)) { g_fs_emu_theme.path = g_strdup(theme); } } // then try to find a bundled / installed theme if (!g_fs_emu_theme.path) { g_fs_emu_theme.path = fs_get_program_data_file( g_fs_emu_theme.name); } if (g_fs_emu_theme.path) { fs_log("theme found at %s\n", g_fs_emu_theme.path); } else { fs_emu_warning(_("Theme not found: %s"), g_fs_emu_theme.name); free(g_fs_emu_theme.name); // resources will not be found, but path should not be NULL... g_fs_emu_theme.path = g_strdup(""); } } else { g_fs_emu_theme.name = g_strdup(""); g_fs_emu_theme.path = g_strdup(""); } load_defaults(); load_theme(); }
void fs_emu_netplay_init() { const char *value; g_send_mutex = fs_mutex_create(); g_connection_mutex = fs_mutex_create(); g_input_event_mutex = fs_mutex_create(); g_input_event_queue = g_queue_new(); g_wait_for_frame_cond = fs_condition_create(); g_wait_for_frame_mutex = fs_mutex_create(); value = fs_config_get_const_string("netplay_server"); if (value) { g_fs_emu_netplay_server = g_strdup(value); } if (!fs_emu_netplay_enabled()) { return; } value = fs_config_get_const_string("netplay_tag"); if (value) { strncpy(g_fs_emu_netplay_tag, value, 4); } else { g_fs_emu_netplay_tag[0] = 'U'; g_fs_emu_netplay_tag[1] = 'N'; g_fs_emu_netplay_tag[2] = 'K'; } g_fs_emu_netplay_tag[3] = '\0'; value = fs_config_get_const_string("netplay_port"); if (value) { g_fs_emu_netplay_port = g_strdup(value); } char *password_value = fs_config_get_string("netplay_password"); if (password_value) { GChecksum *cs = g_checksum_new(G_CHECKSUM_SHA1); g_checksum_update(cs, (unsigned char *) "FSNP", 4); int len = strlen(password_value); for (int i = 0; i < len; i++) { unsigned char c = password_value[i]; // only include ASCII characters if (c < 128) { g_checksum_update(cs, &c, 1); } } gsize digest_len = 20; g_checksum_get_digest(cs, g_fs_emu_netplay_password, &digest_len); free(password_value); g_checksum_free(cs); } }
int fs_config_get_int(const char *key) { const char *value = fs_config_get_const_string(key); if (value == NULL) { return FS_CONFIG_NONE; } return atoi(value); }
static void init_window_overrides() { const char *s = fs_config_get_const_string("viewport"); if (s == NULL) { return; } int pos = 0; while (1) { int result = read_window_override(s, &pos); if (!result) { fs_log("error parsing wiewport transformation\n"); } while(s[pos] == ' ') { ++(pos); } int c = s[(pos)++]; if (c == ';') { continue; } else if (c == ',') { continue; } else if (c == '\0') { break; } else { fs_emu_warning("Unexpected byte (%d) while parsing " "viewport option\n", c); return; } } }
void fs_uae_read_override_actions_for_port(int port) { fs_log("fs_uae_read_override_actions_for_port %d\n", port); fs_emu_input_mapping *mapping = g_joystick_mappings[port]; for (int i = 0; mapping[i].name != NULL; i++) { const char* name = mapping[i].name; if (strcmp(name, "1") == 0) { name = "primary"; } else if (strcmp(name, "2") == 0) { name = "secondary"; } char *key = g_strdup_printf("joystick_port_%d_%s", port, name); const char *value = fs_config_get_const_string(key); if (value == NULL) { continue; } fs_log("check %s = %s\n", key, value); int action = fs_emu_input_action_from_string(value); if (action > -1) { fs_log("override %s => %s (%d)\n", key, value, action); mapping[i].action = action; } free(key); } }
char *fs_config_get_string(const char *key) { const char* value = fs_config_get_const_string(key); if (value) { return g_strdup(value); } return NULL; }
double fs_config_get_double(const char *key) { const char *value = fs_config_get_const_string(key); if (value == NULL) { return FS_CONFIG_NONE; } return g_ascii_strtod(value, NULL); }
const char* fs_uae_base_dir(void) { static const char* path; if (path) { return path; } path = fs_config_get_const_string("base_dir"); if (path) { fs_log("base specified via base_dir option\n"); path = fs_uae_expand_path(path); } if (path == NULL) { // FIXME: deprecated const char *env_path = getenv("FS_UAE_BASE_DIR"); if (env_path && env_path[0]) { path = env_path; fs_log("base specified via FS_UAE_BASE_DIR\n"); fs_emu_deprecated("FS_UAE_BASE_DIR is deprecated"); } } if (path == NULL) { // check for portable dir char buffer[MAX_PATH]; fs_get_application_exe_dir(buffer, MAX_PATH); char *next = g_strdup(buffer); char *orig = g_strdup(":INVALID;"); while (strcmp(orig, next) != 0) { char *test = g_build_filename(next, "Portable.ini", NULL); fs_log("checking %s\n", test); if (fs_path_exists(test)) { path = next; fs_log("using portable base dir %s\n", path); g_free(orig); break; } g_free(test); g_free(orig); orig = next; next = g_path_get_dirname(next); } } if (path == NULL) { path = read_custom_path("base-dir"); } if (path == NULL) { fs_log("- using base dir $DOCUMENTS/FS-UAE\n"); path = g_build_filename(fs_uae_documents_dir(), "FS-UAE", NULL); } int result = g_mkdir_with_parents(path, 0755); if (result == -1) { fs_emu_warning("Could not create base directory " "at %s", path); path = fs_uae_documents_dir(); } fs_log("- using base ($BASE / $FSUAE) directory \"%s\"\n", path); return path; }
int fs_uae_read_memory_option_small(const char *name) { const char *s = fs_config_get_const_string(name); if (!s) { return FS_CONFIG_NONE; } return fs_uae_memory_kb_from_string(s, 1); }
static const char *fs_uae_state_dir_path() { char *free_state_dir_name = NULL; static const char *path; if (!path) { fs_log("fs_uae_state_dir:\n"); path = fs_config_get_const_string("state_dir"); if (path && path[0]) { fs_log("state_dir was explicitly set to: %s\n", path); char *expanded_path = fs_uae_expand_path(path); path = fs_uae_resolve_path(expanded_path, FS_UAE_DIR_PATHS); free(expanded_path); return path; } const char *base = fs_uae_save_states_dir(); fs_log("save_states_dir: %s\n", base); const char *state_dir_name = fs_config_get_const_string( "state_dir_name"); if (!state_dir_name || !state_dir_name[0]) { if (g_fs_uae_config_file_path) { char *n = g_path_get_basename(g_fs_uae_config_file_path); for (int i = strlen(n) - 1; i >= 0; i--) { if (n[i] == '.') { n[i] = '\0'; break; } } free_state_dir_name = g_strdup(n); state_dir_name = free_state_dir_name; g_free(n); } if (!state_dir_name || !state_dir_name[0]) { state_dir_name = "Default"; } fs_log("save_dir_name not set, using %s\n", state_dir_name); } path = g_build_filename(base, state_dir_name, NULL); } if (free_state_dir_name) { g_free(free_state_dir_name); } return path; }
bool fs_config_check_auto(const char *key, const char *value) { const char *s = fs_config_get_const_string(key); if (s == NULL) { return true; } if (value && strcasecmp(s, value) == 0) { return true; } return false; }
void fs_uae_configure_sound_card(amiga_config *c) { const char *card = fs_config_get_const_string(OPTION_SOUND_CARD); if (card != NULL) { if (fs_uae_values_matches(card, "toccata")) { amiga_set_option("toccata", "true"); } else { fs_emu_warning("Unrecognized sound card"); } } }
static void decide_opengl_sync_method() { fs_log("deciding video sync method\n"); const char *c = fs_config_get_const_string("video_sync_method"); if (check_sync_method(c, "swap")) { fs_log("- SYNC_SWAP\n"); g_sync_method = SYNC_SWAP; } else if (check_sync_method(c, "swap-finish")) { fs_log("- SYNC_SWAP_FINISH\n"); g_sync_method = SYNC_SWAP_FINISH; } else if (check_sync_method(c, "finish-swap-finish")) { fs_log("- SYNC_FINISH_SWAP_FINISH\n"); g_sync_method = SYNC_FINISH_SWAP_FINISH; } else if (check_sync_method(c, "sleep-swap-finish")) { fs_log("- SYNC_SLEEP_SWAP_FINISH\n"); g_sync_method = SYNC_SLEEP_SWAP_FINISH; } else if (check_sync_method(c, "finish-sleep-swap-finish")) { fs_log("- SYNC_FINISH_SLEEP_SWAP_FINISH\n"); g_sync_method = SYNC_FINISH_SLEEP_SWAP_FINISH; } else if (check_sync_method(c, "swap-fence")) { fs_log("- SYNC_SWAP_FENCE\n"); g_sync_method = SYNC_SWAP_FENCE; } else if (check_sync_method(c, "swap-sleep-fence")) { fs_log("- SYNC_SWAP_SLEEP_FENCE\n"); g_sync_method = SYNC_SWAP_SLEEP_FENCE; } else if (c) { fs_log("WARNING: unknown sync method specified, using default\n"); g_sync_method = 0; } int fence_support = g_has_nv_fence || g_has_apple_fence || g_has_arb_sync; if (g_sync_method >= SYNC_SWAP_FENCE_START && !fence_support) { fs_log("- no fence support, cannot use this sync method\n"); g_sync_method = 0; } if (g_sync_method == 0) { fs_log("- using default sync method\n"); #if defined(WINDOWS) || defined(MACOSX) fs_log("- SYNC_FINISH_SLEEP_SWAP_FINISH\n"); g_sync_method = SYNC_FINISH_SLEEP_SWAP_FINISH; #else fs_log("- SYNC_FINISH_SWAP_FINISH\n"); g_sync_method = SYNC_FINISH_SWAP_FINISH; #endif } }
static void fs_emu_load_default_shader() { const char *name = fs_config_get_const_string("shader"); if (!name) { return; } char *path = find_shader(name); if (!path) { fs_emu_warning(_("Shader not found: %s"), name); return; } fs_emu_shader *shader= g_new0(fs_emu_shader, 1); shader->path = path; fs_emu_load_shader(shader); fs_gl_add_context_notification(context_notification_handler, shader); g_active_shader = shader; }
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 process_key_value(const char *key, char *value, int force) { char *key_lower = g_ascii_strdown(key, -1); g_strdelimit (key_lower, "-", '_'); // using fs_config_get_const_string here instead of just // g_hash_table_lookup, since that also checks for empty strings, which // should be treated as non-existing keys if (!force && fs_config_get_const_string(key_lower)) { fs_log("%s = %s (ignored)\n", key_lower, value); g_free(key_lower); g_free(value); } else { g_strstrip(value); fs_log("%s = %s\n", key_lower, value); // hash table now owns both key_lower and value g_hash_table_insert(g_hash_table, key_lower, value); } }
bool fs_config_exists(const char *key) { return fs_config_get_const_string(key) != NULL; }
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_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"); } }
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; }
static void configure_cpu(void) { bool uae_cpu_24bit_addressing = !cfg->cpu_32bit_addressing; const char *uae_cpu_model = cfg->default_cpu; const char *uae_fpu_model = cfg->default_fpu; const char *uae_mmu_model = cfg->default_mmu; //bool allow_6888x_fpu = false; //bool allow_68040_fpu = false; //bool allow_68060_fpu = false; const char *cpu = fs_config_get_const_string(OPTION_CPU); if (cpu == NULL) { cpu = cfg->accelerator_cpu; } if (cpu == NULL || fs_uae_values_matches(cpu, "auto")) { /* Go with the already configured value */ } else if (fs_uae_values_matches(cpu, "68000")) { uae_cpu_24bit_addressing = true; uae_cpu_model = "68000"; uae_fpu_model = "0"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68010")) { uae_cpu_24bit_addressing = true; uae_cpu_model = "68010"; uae_fpu_model = "0"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68EC020")) { uae_cpu_24bit_addressing = true; uae_cpu_model = "68020"; uae_fpu_model = cfg->default_fpu_noninternal; uae_mmu_model = "0"; //allow_6888x_fpu = true; } else if (fs_uae_values_matches(cpu, "68020")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68020"; uae_fpu_model = cfg->default_fpu_noninternal; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68EC030")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68030"; uae_fpu_model = "0"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68030")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68030"; uae_fpu_model = cfg->default_fpu_noninternal; uae_mmu_model = "68030"; } else if (fs_uae_values_matches(cpu, "68EC040")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68040"; uae_fpu_model = "0"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68LC040")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68040"; uae_fpu_model = "0"; uae_mmu_model = "68040"; } else if (fs_uae_values_matches(cpu, "68040")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68040"; uae_fpu_model = "68040"; uae_mmu_model = "68040"; } else if (fs_uae_values_matches(cpu, "68040-NOMMU")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68040"; uae_fpu_model = "68040"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68EC060")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68060"; uae_fpu_model = "0"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68LC060")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68060"; uae_fpu_model = "0"; uae_mmu_model = "68060"; } else if (fs_uae_values_matches(cpu, "68060-NOMMU")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68060"; uae_fpu_model = "68060"; uae_mmu_model = "0"; } else if (fs_uae_values_matches(cpu, "68060")) { uae_cpu_24bit_addressing = false; uae_cpu_model = "68060"; uae_fpu_model = "68060"; uae_mmu_model = "68060"; } else { fs_emu_warning("Unknown CPU specified"); } const char *fpu = fs_config_get_const_string(OPTION_FPU); if (fpu == NULL || fs_uae_values_matches(fpu, "auto")) { /* Go with the already configured value */ } else if (fs_uae_values_matches(fpu, "0")) { uae_fpu_model = "0"; } else if (fs_uae_values_matches(fpu, "68881")) { if (fs_uae_values_matches(uae_cpu_model, "68020") || fs_uae_values_matches(uae_cpu_model, "68030")) { uae_fpu_model = "68881"; } else { fs_emu_warning("68881 FPU must be paired with 68020/68030 CPU\n"); } } else if (fs_uae_values_matches(fpu, "68882")) { if (strcmp(uae_cpu_model, "68020") == 0 || strcmp(uae_cpu_model, "68030") == 0) { uae_fpu_model = "68882"; } else { fs_emu_warning("68882 FPU must be paired with 68020/68030 CPU\n"); } } else if (fs_uae_values_matches(fpu, "68040")) { if (strcmp(uae_cpu_model, "68040") == 0) { uae_fpu_model = "68040"; } else { fs_emu_warning("68040 FPU must be paired with 68040 CPU"); } } else if (fs_uae_values_matches(fpu, "68060")) { if (strcmp(uae_cpu_model, "68060") == 0) { uae_fpu_model = "68060"; } else { fs_emu_warning("68060 FPU must be paired with 68060 CPU"); } } else { fs_emu_warning("Unknown FPU specified"); } const char *mmu = fs_config_get_const_string(OPTION_MMU); if (mmu == NULL || fs_uae_values_matches(mmu, "auto")) { /* Go with the already configured value */ } else if (fs_uae_values_matches(mmu, "0")) { uae_mmu_model = "0"; } else if (fs_uae_values_matches(mmu, "68030")) { if (strcmp(uae_cpu_model, "68030") == 0) { uae_mmu_model = "68030"; } else { fs_emu_warning("68030 MMU must be paired with 68030 CPU"); } } else if (fs_uae_values_matches(mmu, "68040")) { if (strcmp(uae_cpu_model, "68040") == 0) { uae_mmu_model = "68040"; } else { fs_emu_warning("68040 MMU must be paired with 68040 CPU"); } } else if (fs_uae_values_matches(mmu, "68060")) { if (strcmp(uae_cpu_model, "68060") == 0) { uae_mmu_model = "68060"; } else { fs_emu_warning("68060 MMU must be paired with 68060 CPU"); } } else { fs_emu_warning("Unknown MMU specified"); } if (uae_cpu_model[0]) { amiga_set_option("cpu_model", uae_cpu_model); } if (uae_fpu_model[0]) { amiga_set_option("fpu_model", uae_fpu_model); } if (uae_mmu_model[0]) { amiga_set_option("mmu_model", uae_mmu_model); } if (uae_cpu_24bit_addressing) { amiga_set_option("cpu_24bit_addressing", "true"); } else { amiga_set_option("cpu_24bit_addressing", "false"); } cfg->cpu_32bit_addressing = !uae_cpu_24bit_addressing; cfg->allow_z3_memory = !uae_cpu_24bit_addressing; int accuracy = fs_config_get_int("accuracy"); if (accuracy == FS_CONFIG_NONE) { accuracy = 1; } int blitter_mode = BLITTER_MODE_NORMAL; int cpu_mode = CPU_MODE_CYCLE_EXACT; int cpu_speed = CPU_SPEED_REAL; if (strcmp(uae_cpu_model, "68030") == 0 || strcmp(uae_cpu_model, "68040") == 0 || strcmp(uae_cpu_model, "68060") == 0) { cpu_speed = CPU_SPEED_MAX; cpu_mode = CPU_MODE_NONCOMPATIBLE; } else { cpu_speed = CPU_SPEED_REAL; if (accuracy > 0) { cpu_mode = CPU_MODE_CYCLE_EXACT; } else if (accuracy == 0) { cpu_mode = CPU_MODE_COMPATIBLE; } else if (accuracy < 0) { cpu_mode = CPU_MODE_NONCOMPATIBLE; } } if (cpu_mode == CPU_MODE_CYCLE_EXACT && strcmp(uae_cpu_model, "68000") == 0) { blitter_mode = BLITTER_MODE_NORMAL; } else if (accuracy < 0) { blitter_mode = BLITTER_MODE_IMMEDIATE; } else { blitter_mode = BLITTER_MODE_WAITING; } if (cpu_speed == CPU_SPEED_MAX) { amiga_set_option("cpu_speed", "max"); } else { amiga_set_option("cpu_speed", "real"); } if (cpu_mode == CPU_MODE_CYCLE_EXACT) { amiga_set_option("blitter_cycle_exact", "true"); amiga_set_option("cpu_compatible", "true"); amiga_set_option("cpu_cycle_exact", "true"); } else if (cpu_mode == CPU_MODE_COMPATIBLE) { amiga_set_option("blitter_cycle_exact", "false"); amiga_set_option("cpu_compatible", "true"); amiga_set_option("cpu_cycle_exact", "false"); } else if (cpu_mode == CPU_MODE_NONCOMPATIBLE) { amiga_set_option("blitter_cycle_exact", "false"); amiga_set_option("cpu_compatible", "false"); amiga_set_option("cpu_cycle_exact", "false"); } if (blitter_mode == BLITTER_MODE_NORMAL) { amiga_set_option("waiting_blits", "false"); amiga_set_option("immediate_blits", "false"); } else if (blitter_mode == BLITTER_MODE_WAITING) { amiga_set_option("waiting_blits", "true"); amiga_set_option("immediate_blits", "false"); } else if (blitter_mode == BLITTER_MODE_IMMEDIATE) { amiga_set_option("waiting_blits", "false"); amiga_set_option("immediate_blits", "true"); } int cpu_idle = fs_config_get_int_clamped(OPTION_CPU_IDLE, 0, 10); if (cpu_idle == FS_CONFIG_NONE) { cpu_idle = cfg->cpu_idle; } if (cpu_idle != FS_CONFIG_NONE) { fs_log("Setting cpu_idle to %d\n", cpu_idle); amiga_set_cpu_idle(cpu_idle); } }
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; } }
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); } }
static void load_theme() { fs_log("loading theme \"%s\"\n", g_fs_emu_theme.path); char *p = fs_path_join(g_fs_emu_theme.path, "theme.conf", NULL); if (fs_path_exists(p)) { fs_config_read_file(p, 1); } free(p); char *cv; int iv; iv = fs_config_get_int("theme_width"); if (iv != FS_CONFIG_NONE && iv > 0) { g_fs_emu_theme.width = iv; } iv = fs_config_get_int("theme_height"); if (iv != FS_CONFIG_NONE && iv > 0) { g_fs_emu_theme.height = iv; } set_color_from_string(g_fs_emu_theme.floor_color_1, fs_config_get_const_string("theme_floor_color_1")); set_color_from_string(g_fs_emu_theme.floor_color_2, fs_config_get_const_string("theme_floor_color_2")); set_color_from_string(g_fs_emu_theme.wall_color_1, fs_config_get_const_string("theme_wall_color_1")); set_color_from_string(g_fs_emu_theme.wall_color_2, fs_config_get_const_string("theme_wall_color_2")); iv = fs_config_get_int("theme_floor_height"); if (iv != FS_CONFIG_NONE) { g_fs_emu_theme.floor_height = iv; } cv = fs_config_get_string("theme_overlay_image"); if (cv) { free(g_fs_emu_theme.overlay_image); g_fs_emu_theme.overlay_image = cv; } set_color_from_string(g_fs_emu_theme.fade_color, fs_config_get_const_string("theme_fade_color")); set_color_from_string(g_fs_emu_theme.heading_color, fs_config_get_const_string("theme_heading_color")); set_color_from_string(g_fs_emu_theme.item_color, fs_config_get_const_string("theme_item_color")); for (int i = 0; i < FS_EMU_MAX_OVERLAYS; i++) { char *name; int val; // the first options read here are old compatibility options name = fs_strdup_printf("theme_custom_%d_x", i - FS_EMU_FIRST_CUSTOM_OVERLAY); val = fs_config_get_int(name); free(name); if (val != FS_CONFIG_NONE) { //printf("x is %d\n", val); g_fs_emu_theme.overlays[i].x = (double) val / g_fs_emu_theme.width; } name = fs_strdup_printf("theme_custom_%d_y", i - FS_EMU_FIRST_CUSTOM_OVERLAY); val = fs_config_get_int(name); free(name); if (val != FS_CONFIG_NONE) { g_fs_emu_theme.overlays[i].y = (double) val / g_fs_emu_theme.height; } if (!g_fs_emu_theme.overlays[i].name) { continue; } // these are new theme / overlay options name = fs_strdup_printf("theme_%s_pos", g_fs_emu_theme.overlays[i].name); const char *csval = fs_config_get_const_string(name); free(name); if (csval) { int x, y; if (sscanf(csval, "%d,%d", &x, &y) == 2) { g_fs_emu_theme.overlays[i].x = (double) x / g_fs_emu_theme.width; g_fs_emu_theme.overlays[i].y = (double) y / g_fs_emu_theme.height; } } } #ifdef WITH_LUA fs_emu_theme_init_lua(); #endif }
void fs_config_set_string_if_unset(const char *key, const char *value) { if (fs_config_get_const_string(key) == NULL) { fs_config_set_string(key, value); } }
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"); SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "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 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; #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; }