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 void update_cd_menu(fs_emu_menu *menu) {
fs_emu_menu_item *item = menu->items[1];
const char *inserted_path = amiga_cdrom_get_file(menu->idata);
// FIXME: enable later
//fs_emu_menu_item_set_enabled(item, inserted_path[0] != '\0');
for (int i = 0; i < menu->count - 2; i++) {
item = menu->items[i + 2];
char *key = g_strdup_printf("cdrom_image_%d", i);
char* path = fs_config_get_string(key);
free(key);
if (path == NULL) {
fs_emu_menu_item_set_enabled(item, 0);
continue;
}
if (strcmp(inserted_path, path) == 0) {
fs_emu_menu_item_set_enabled(item, 0);
// FIXME: move somewhere else?
menu->index = 2 + i;
}
else {
fs_emu_menu_item_set_enabled(item, 1);
}
free(path);
}
}
void fs_uae_configure_input()
{
fs_uae_configure_mouse();
fs_emu_log("configuring joystick ports:\n");
amiga_set_option("joyport0", "none");
amiga_set_option("joyport1", "none");
fs_uae_configure_actions();
//fs_emu_set_action_function(joystick_action);
char *value;
value = fs_config_get_string("joystick_port_0");
if (value == NULL) {
value = g_strdup("mouse");
}
configure_joystick_port(0, value, "joyport0", "joy0");
g_free(value);
value = fs_config_get_string("joystick_port_1");
if (value == NULL) {
value = g_strdup("auto");
}
configure_joystick_port(1, value, "joyport1", "joy1");
g_free(value);
value = fs_config_get_string("joystick_port_2");
if (value == NULL) {
value = g_strdup("nothing");
}
configure_joystick_port(2, value, "joyport2", "joy2");
g_free(value);
value = fs_config_get_string("joystick_port_3");
if (value == NULL) {
value = g_strdup("nothing");
}
configure_joystick_port(3, value, "joyport3", "joy3");
g_free(value);
value = fs_config_get_string("joystick_port_4");
if (value == NULL) {
value = g_strdup("nothing");
}
configure_joystick_port(4, value, "joyport4", "joy4");
g_free(value);
}
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_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);
}
}
void fs_uae_configure_input()
{
fs_uae_configure_mouse();
fs_emu_log("configuring joystick ports:\n");
amiga_set_option("joyport0", "none");
amiga_set_option("joyport1", "none");
fs_uae_configure_actions();
char *value;
value = fs_config_get_string("joystick_port_1");
if (!value) {
value = g_strdup("auto");
}
configure_joystick_port(1, value, "joyport1", "joy1");
g_free(value);
value = fs_config_get_string("joystick_port_0");
if (!value) {
value = g_strdup("auto");
}
configure_joystick_port(0, value, "joyport0", "joy0");
g_free(value);
for (int i = 2; i < FS_UAE_NUM_INPUT_PORTS; i++) {
gchar *key = g_strdup_printf("joystick_port_%d", i);
value = fs_config_get_string(key);
g_free(key);
if (value == NULL) {
value = g_strdup("nothing");
}
gchar *key2 = g_strdup_printf("joyport%d", i);
gchar *key3 = g_strdup_printf("joy%d", i);
configure_joystick_port(i, value, key2, key3);
g_free(key3);
g_free(key2);
g_free(value);
}
}
static char *get_or_create_default_dir(const char *name, const char *key1,
const char *key2, const char *dashed_key, int create, int cache)
{
char *path = NULL;
if (path == NULL && key1 != NULL) {
path = fs_config_get_string(key1);
}
if (path == NULL && key2 != NULL) {
path = fs_config_get_string(key2);
}
if (path == NULL && dashed_key != NULL) {
path = read_custom_path(dashed_key);
}
if (path == NULL) {
if (cache) {
path = g_build_filename(fs_uae_cache_dir(), name, NULL);
} else {
path = g_build_filename(fs_uae_base_dir(), name, NULL);
}
}
char *expanded_path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path(expanded_path, FS_UAE_DIR_PATHS);
free(expanded_path);
if (create) {
int result = g_mkdir_with_parents(path, 0755);
if (result == -1) {
fs_emu_warning("Could not create %s directory", name);
free(path);
path = g_strdup(fs_uae_base_dir());
}
}
fs_log("- using \"%s\" directory \"%s\"\n", name, path);
return path;
}
static void insert_cdrom(int drive_index, int disk_index) {
if (disk_index == -1) {
fs_emu_log("menu: eject CD from drive %d\n", drive_index);
amiga_cdrom_set_file(drive_index, "");
return;
}
fs_emu_log("menu: insert CD index %d into drive %d\n", disk_index,
drive_index);
char *key = g_strdup_printf("cdrom_image_%d", disk_index);
char* path = fs_config_get_string(key);
free(key);
if (path == NULL) {
fs_emu_log("no CD at this index in CD-ROM list\n");
}
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_CD_PATHS);
amiga_cdrom_set_file(drive_index, path);
free(path);
}
void fs_uae_configure_cdrom() {
/*
if (g_fs_uae_amiga_model != MODEL_CDTV && g_fs_uae_amiga_model != MODEL_CD32) {
return;
}
*/
fs_emu_log("configure_cdrom\n");
char *path = fs_config_get_string("cdrom_drive_0");
if (path) {
path = fs_uae_expand_path_and_free(path);
path = fs_uae_resolve_path_and_free(path, FS_UAE_CD_PATHS);
//set_default_dirs_from_file_path(path);
char* temp = fs_strconcat(path, ",", NULL);
amiga_set_option("cdimage0", temp);
free(temp);
free(path);
if (g_fs_uae_amiga_model != MODEL_CDTV &&
g_fs_uae_amiga_model != MODEL_CD32) {
amiga_set_option("scsi", "true");
amiga_map_cd_drives(1);
}
}
}
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 = "amigacd32";
auto_mode = AMIGA_JOYPORT_CD32JOY;
}
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) {
p->new_mode = AMIGA_JOYPORT_MOUSE;
strcpy(p->device, "MOUSE");
}
else {
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");
}
}
}
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);
}
char *key = g_strdup_printf("joystick_port_%d_mode", port);
char *mode_string = fs_config_get_string(key);
free(key);
if (mode_string) {
char *mode_lower = g_ascii_strdown(mode_string, -1);
free(mode_string);
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);
}
}
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 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_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);
}
*/
}
static int media_menu_function(fs_emu_menu_item *menu_item,
void **result_data) {
int index = fs_emu_menu_item_get_idata(menu_item);
int drive, type;
get_drive_for_index(index, &type, &drive);
fs_emu_menu_item *item;
fs_emu_menu *menu = fs_emu_menu_new();
if (type == 0) { // floppy
fs_emu_log("disk_menu_function for df%d\n");
char *str;
menu->idata = drive;
fs_emu_menu_set_update_function(menu, update_disk_menu);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
/// TRANSLATORS: This is a menu entry and must not be too long
str = g_strdup_printf(_("Insert Into DF%d"), drive);
fs_emu_menu_item_set_title(item, str);
free(str);
fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_HEADING);
for (int i = -1; i < AMIGA_FLOPPY_LIST_SIZE; i++) {
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
if (i == -1) {
fs_emu_menu_item_set_title(item, _("Eject"));
}
else {
const char *path = amiga_floppy_get_list_entry(i);
str = get_floppy_label(path);
fs_emu_menu_item_set_title(item, str);
free(str);
}
//fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_ITEM);
fs_emu_menu_item_set_idata(item, i);
if (drive == 0) {
fs_emu_menu_item_set_activate_function(item, df0_function);
}
else if (drive == 1) {
fs_emu_menu_item_set_activate_function(item, df1_function);
}
else if (drive == 2) {
fs_emu_menu_item_set_activate_function(item, df2_function);
}
else if (drive == 3) {
fs_emu_menu_item_set_activate_function(item, df3_function);
}
}
}
else if (type == 1) {
fs_emu_log("cd_menu_function for CD %d\n");
char *str;
menu->idata = drive;
fs_emu_menu_set_update_function(menu, update_cd_menu);
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
/// TRANSLATORS: This is a menu entry and must not be too long
str = g_strdup_printf(_("Insert Into CD%d"), drive);
fs_emu_menu_item_set_title(item, str);
g_free(str);
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, _("Eject"));
fs_emu_menu_item_set_idata(item, -1);
fs_emu_menu_item_set_activate_function(item, cd0_function);
// FIXME: Disabled because inserting nothing seems to make it crash,
// currently -needs to be investigated
//fs_emu_menu_item_set_enabled(item, 0);
for (int i = 0; ; i++) {
// FIXME: GET FROM UAE OPTIONS...?
char *key = g_strdup_printf("cdrom_image_%d", i);
char *path = fs_config_get_string(key);
free(key);
if (path == NULL) {
if (i == 0) {
// try starting from index 1
continue;
}
break;
}
item = fs_emu_menu_item_new();
fs_emu_menu_append_item(menu, item);
str = get_floppy_label(path);
fs_emu_menu_item_set_title(item, str);
free(str);
//fs_emu_menu_item_set_type(item, FS_EMU_MENU_ITEM_TYPE_ITEM);
fs_emu_menu_item_set_idata(item, i);
if (drive == 0) {
fs_emu_menu_item_set_activate_function(item, cd0_function);
}
free(path);
}
}
*result_data = menu;
return FS_EMU_MENU_RESULT_MENU;
}