static bool input_try_autoconfigure_joypad_from_conf(config_file_t *conf, unsigned index, const char *name, const char *driver, bool block_osd_spam)
{
if (!conf)
return false;
char ident[1024];
char input_driver[1024];
*ident = *input_driver = '\0';
config_get_array(conf, "input_device", ident, sizeof(ident));
config_get_array(conf, "input_driver", input_driver, sizeof(input_driver));
if (!strcmp(ident, name) && !strcmp(driver, input_driver))
{
g_settings.input.autoconfigured[index] = true;
input_autoconfigure_joypad_conf(conf, g_settings.input.autoconf_binds[index]);
char msg[512];
snprintf(msg, sizeof(msg), "Joypad port #%u (%s) configured.",
index, name);
if (!block_osd_spam)
msg_queue_push(g_extern.msg_queue, msg, 0, 60);
RARCH_LOG("%s\n", msg);
return true;
}
return false;
}
static bool input_try_autoconfigure_joypad_from_conf(config_file_t *conf,
unsigned idx, const char *name, const char *drv,
int32_t vid, int32_t pid, bool block_osd_spam)
{
char ident[PATH_MAX_LENGTH], ident_idx[PATH_MAX_LENGTH];
char input_driver[PATH_MAX_LENGTH], msg[PATH_MAX_LENGTH];
int input_vid = 0, input_pid = 0;
bool cond_found_idx, cond_found_general,
cond_found_vid = false, cond_found_pid = false;
if (!conf)
return false;
*ident = *input_driver = '\0';
config_get_array(conf, "input_device", ident, sizeof(ident));
config_get_array(conf, "input_driver", input_driver, sizeof(input_driver));
config_get_int(conf, "input_vendor_id", &input_vid);
config_get_int(conf, "input_product_id", &input_pid);
snprintf(ident_idx, sizeof(ident_idx), "%s_p%u", ident, idx);
#if 0
RARCH_LOG("ident_idx: %s\n", ident_idx);
#endif
cond_found_idx = !strcmp(ident_idx, name);
cond_found_general = !strcmp(ident, name) && !strcmp(drv, input_driver);
if ((vid != 0) && (input_vid != 0))
cond_found_vid = (vid == input_vid);
if ((pid != 0) && (input_pid != 0))
cond_found_pid = (pid == input_pid);
/* If Vendor ID and Product ID matches, we've found our
* entry. */
if (cond_found_vid && cond_found_pid)
goto found;
/* Check for name match. */
if (cond_found_idx)
goto found;
else if (cond_found_general)
goto found;
return false;
found:
g_settings.input.autoconfigured[idx] = true;
input_autoconfigure_joypad_conf(conf, g_settings.input.autoconf_binds[idx]);
snprintf(msg, sizeof(msg), "Joypad port #%u (%s) configured.",
idx, name);
if (!block_osd_spam)
rarch_main_msg_queue_push(msg, 0, 60, false);
RARCH_LOG("%s\n", msg);
return true;
}
static int input_try_autoconfigure_joypad_from_conf(config_file_t *conf,
autoconfig_params_t *params)
{
char ident[PATH_MAX_LENGTH] = {0};
char input_driver[PATH_MAX_LENGTH] = {0};
int input_vid = 0;
int input_pid = 0;
int score = 0;
if (!conf)
return false;
config_get_array(conf, "input_device", ident, sizeof(ident));
config_get_array(conf, "input_driver", input_driver, sizeof(input_driver));
config_get_int (conf, "input_vendor_id", &input_vid);
config_get_int (conf, "input_product_id", &input_pid);
/* Check for VID/PID */
if ( (params->vid == input_vid)
&& (params->pid == input_pid)
&& params->vid != 0
&& params->pid != 0
&& input_vid != 0
&& input_pid != 0)
{
score += 3;
#if 0
RARCH_LOG("Autodetect: VID/PID match score=%d\n", score);
#endif
}
/* Check for name match */
if (string_is_equal(ident, params->name))
{
score += 2;
#if 0
RARCH_LOG("Autodetect: exact name match score=%d\n", score);
#endif
}
else
{
if (!string_is_empty(ident)
&& !strncmp(params->name, ident, strlen(ident)))
{
score += 1;
#if 0
RARCH_LOG("Autodetect: partial name match score=%d\n", score);
#endif
}
}
#if 0
RARCH_LOG("Autodetect: configuration file: %s score: %d\n",
conf->path, score);
#endif
return score;
}
static void input_autoconfigure_joypad_add(
config_file_t *conf,
autoconfig_params_t *params)
{
bool block_osd_spam;
char msg[PATH_MAX_LENGTH] = {0};
char display_name[PATH_MAX_LENGTH] = {0};
char device_type[PATH_MAX_LENGTH] = {0};
settings_t *settings = config_get_ptr();
config_get_array(conf, "input_device_display_name", display_name, sizeof(display_name));
config_get_array(conf, "input_device_type", device_type, sizeof(device_type));
if (!settings)
return;
/* This will be the case if input driver is reinitialized.
* No reason to spam autoconfigure messages every time. */
block_osd_spam = settings->input.autoconfigured[params->idx]
&& *params->name;
settings->input.autoconfigured[params->idx] = true;
input_autoconfigure_joypad_conf(conf,
settings->input.autoconf_binds[params->idx]);
if (!strcmp(device_type,"remote"))
{
if (display_name[0] != '\0' || strcmp(display_name, ""))
snprintf(msg, sizeof(msg), "%s configured",
display_name);
else
snprintf(msg, sizeof(msg), "%s configured",
params->name);
if(!remote_is_bound)
rarch_main_msg_queue_push(msg, 0, 60, false);
remote_is_bound = true;
}
else
{
if (display_name[0] != '\0' || strcmp(display_name, ""))
snprintf(msg, sizeof(msg), "%s configured in port #%u.",
display_name, params->idx);
else
snprintf(msg, sizeof(msg), "%s configured in port #%u.",
params->name, params->idx);
if (!block_osd_spam)
rarch_main_msg_queue_push(msg, 0, 60, false);
}
#if 0
RARCH_LOG("Autodetect: %s\n", msg);
#endif
}
static int input_autoconfigure_joypad_try_from_conf(config_file_t *conf,
autoconfig_params_t *params)
{
char ident[256];
char input_driver[32];
int tmp_int = 0;
int input_vid = 0;
int input_pid = 0;
int score = 0;
ident[0] = input_driver[0] = '\0';
config_get_array(conf, "input_device", ident, sizeof(ident));
config_get_array(conf, "input_driver", input_driver, sizeof(input_driver));
if (config_get_int (conf, "input_vendor_id", &tmp_int))
input_vid = tmp_int;
if (config_get_int (conf, "input_product_id", &tmp_int))
input_pid = tmp_int;
if (params->vid == BLISSBOX_VID)
input_pid = BLISSBOX_PID;
/* Check for VID/PID */
if ( (params->vid == input_vid)
&& (params->pid == input_pid)
&& (params->vid != 0)
&& (params->pid != 0)
&& (params->vid != BLISSBOX_VID)
&& (params->pid != BLISSBOX_PID))
score += 3;
/* Check for name match */
if (!string_is_empty(params->name)
&& !string_is_empty(ident)
&& string_is_equal(ident, params->name))
score += 2;
#if 0
else
{
if (string_is_empty(params->name))
RARCH_LOG("[Autoconf]: failed match because params->name was empty\n");
else if (string_is_empty(ident))
RARCH_LOG("[Autoconf]: failed match because ident was empty\n");
else
RARCH_LOG("[Autoconf]: failed match because ident '%s' != param->name '%s'\n",
ident, params->name);
}
#endif
return score;
}
/**
* video_shader_parse_textures:
* @conf : Preset file to read from.
* @shader : Shader pass handle.
*
* Parses shader textures.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool video_shader_parse_textures(config_file_t *conf,
struct video_shader *shader)
{
const char *id = NULL;
char *save = NULL;
char textures[1024] = {0};
if (!config_get_array(conf, "textures", textures, sizeof(textures)))
return true;
for (id = strtok_r(textures, ";", &save);
id && shader->luts < GFX_MAX_TEXTURES;
shader->luts++, id = strtok_r(NULL, ";", &save))
{
char id_filter[64] = {0};
char id_wrap[64] = {0};
char wrap_mode[64] = {0};
char id_mipmap[64] = {0};
bool mipmap = false;
bool smooth = false;
if (!config_get_array(conf, id, shader->lut[shader->luts].path,
sizeof(shader->lut[shader->luts].path)))
{
RARCH_ERR("Cannot find path to texture \"%s\" ...\n", id);
return false;
}
strlcpy(shader->lut[shader->luts].id, id,
sizeof(shader->lut[shader->luts].id));
snprintf(id_filter, sizeof(id_filter), "%s_linear", id);
if (config_get_bool(conf, id_filter, &smooth))
shader->lut[shader->luts].filter = smooth ?
RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST;
else
shader->lut[shader->luts].filter = RARCH_FILTER_UNSPEC;
snprintf(id_wrap, sizeof(id_wrap), "%s_wrap_mode", id);
if (config_get_array(conf, id_wrap, wrap_mode, sizeof(wrap_mode)))
shader->lut[shader->luts].wrap = wrap_str_to_mode(wrap_mode);
snprintf(id_mipmap, sizeof(id_mipmap), "%s_mipmap", id);
if (config_get_bool(conf, id_mipmap, &mipmap))
shader->lut[shader->luts].mipmap = mipmap;
else
shader->lut[shader->luts].mipmap = false;
}
return true;
}
static void input_autoconfigure_joypad_add(
config_file_t *conf,
autoconfig_params_t *params)
{
char msg[PATH_MAX_LENGTH] = {0};
char buf[PATH_MAX_LENGTH] = {0};
settings_t *settings = config_get_ptr();
config_get_array(conf, "input_display_name", buf, sizeof(buf));
/* This will be the case if input driver is reinitialized.
* No reason to spam autoconfigure messages every time. */
bool block_osd_spam = settings &&
settings->input.autoconfigured[params->idx] && *params->name;
if (!settings)
return;
settings->input.autoconfigured[params->idx] = true;
input_autoconfigure_joypad_conf(conf,
settings->input.autoconf_binds[params->idx]);
if (buf[0] != '\0' || strcmp(buf, ""))
snprintf(msg, sizeof(msg), "%s configured in port #%u.",
buf, params->idx);
else
snprintf(msg, sizeof(msg), "%s configured in port #%u.",
params->name, params->idx);
if (!block_osd_spam)
rarch_main_msg_queue_push(msg, 0, 60, false);
RARCH_LOG("%s\n", msg);
}
/**
* video_shader_set_current_parameters:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Reads the current value for all parameters from config file.
*
* Returns: true (1) if successful, otherwise false (0).
**/
bool video_shader_resolve_current_parameters(config_file_t *conf,
struct video_shader *shader)
{
char parameters[4096];
const char *id = NULL;
char *save = NULL;
if (!conf)
return false;
parameters[0] = '\0';
/* Read in parameters which override the defaults. */
if (!config_get_array(conf, "parameters",
parameters, sizeof(parameters)))
return true;
for (id = strtok_r(parameters, ";", &save); id;
id = strtok_r(NULL, ";", &save))
{
struct video_shader_parameter *parameter = (struct video_shader_parameter*)
video_shader_parse_find_parameter(shader->parameters, shader->num_parameters, id);
if (!parameter)
{
RARCH_WARN("[CGP/GLSLP]: Parameter %s is set in the preset, but no shader uses this parameter, ignoring.\n", id);
continue;
}
if (!config_get_float(conf, id, ¶meter->current))
RARCH_WARN("[CGP/GLSLP]: Parameter %s is not set in preset.\n", id);
}
return true;
}
void input_config_parse_joy_axis(config_file_t *conf, const char *prefix,
const char *axis, struct retro_keybind *bind)
{
char tmp[64] = {0};
char key[64] = {0};
char key_label[64] = {0};
char *tmp_a = NULL;
snprintf(key, sizeof(key), "%s_%s_axis", prefix, axis);
snprintf(key_label, sizeof(key_label), "%s_%s_axis_label", prefix, axis);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
if (!strcmp(tmp, "nul"))
bind->joyaxis = AXIS_NONE;
else if (strlen(tmp) >= 2 && (*tmp == '+' || *tmp == '-'))
{
int i_axis = strtol(tmp + 1, NULL, 0);
if (*tmp == '+')
bind->joyaxis = AXIS_POS(i_axis);
else
bind->joyaxis = AXIS_NEG(i_axis);
}
/* Ensure that D-pad emulation doesn't screw this over. */
bind->orig_joyaxis = bind->joyaxis;
}
if (config_get_string(conf, key_label, &tmp_a))
strlcpy(bind->joyaxis_label, tmp_a, sizeof(bind->joyaxis_label));
}
bool config_get_path(config_file_t *conf, const char *key, char *buf, size_t size)
{
#if defined(_WIN32) || defined(RARCH_CONSOLE)
return config_get_array(conf, key, buf, size);
#else
struct entry_list *list = conf->entries;
while (list)
{
if (strcmp(key, list->key) == 0)
{
const char *value = list->value;
if (*value == '~')
{
const char *home = getenv("HOME");
if (home)
{
size_t src_size = strlcpy(buf, home, size);
if (src_size >= size)
return false;
buf += src_size;
size -= src_size;
value++;
}
}
return strlcpy(buf, value, size) < size;
}
list = list->next;
}
return false;
#endif
}
static void salamander_init(void)
{
CellPadData pad_data;
cellPadInit(7);
cellPadGetData(0, &pad_data);
if(pad_data.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_TRIANGLE)
{
//override path, boot first executable in cores directory
RARCH_LOG("Fallback - Will boot first executable in RetroArch cores/ directory.\n");
find_and_set_first_file();
}
else
{
//normal executable loading path
char tmp_str[PATH_MAX];
bool config_file_exists = false;
if (path_file_exists(config_path))
config_file_exists = true;
//try to find CORE executable
char core_executable[1024];
fill_pathname_join(core_executable, default_paths.core_dir, "CORE.SELF", sizeof(core_executable));
if(path_file_exists(core_executable))
{
//Start CORE executable
strlcpy(libretro_path, core_executable, sizeof(libretro_path));
RARCH_LOG("Start [%s].\n", libretro_path);
}
else
{
if (config_file_exists)
{
config_file_t * conf = config_file_new(config_path);
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
strlcpy(libretro_path, tmp_str, sizeof(libretro_path));
}
if (!config_file_exists || !strcmp(libretro_path, ""))
find_and_set_first_file();
else
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path);
if (!config_file_exists)
{
config_file_t *new_conf = config_file_new(NULL);
config_set_string(new_conf, "libretro_path", libretro_path);
config_file_write(new_conf, config_path);
config_file_free(new_conf);
}
}
}
cellPadEnd();
}
void input_config_parse_joy_button(config_file_t *conf, const char *prefix,
const char *btn, struct retro_keybind *bind)
{
char tmp[64] = {0};
char key[64] = {0};
char key_label[64] = {0};
char *tmp_a = NULL;
snprintf(key, sizeof(key), "%s_%s_btn", prefix, btn);
snprintf(key_label, sizeof(key_label), "%s_%s_btn_label", prefix, btn);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
btn = tmp;
if (!strcmp(btn, "nul"))
bind->joykey = NO_BTN;
else
{
if (*btn == 'h')
parse_hat(bind, btn + 1);
else
bind->joykey = strtoull(tmp, NULL, 0);
}
}
if (config_get_string(conf, key_label, &tmp_a))
strlcpy(bind->joykey_label, tmp_a, sizeof(bind->joykey_label));
}
void input_config_parse_joy_button(config_file_t *conf, const char *prefix,
const char *btn, struct retro_keybind *bind)
{
char str[256] = {0};
char tmp[64] = {0};
char key[64] = {0};
char key_label[64] = {0};
char *tmp_a = NULL;
fill_pathname_join_delim(str, prefix, btn, '_', sizeof(str));
fill_pathname_join_delim(key, str, "btn", '_', sizeof(key));
fill_pathname_join_delim(key_label, str, "btn_label", '_', sizeof(key_label));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
btn = tmp;
if (string_is_equal(btn, "nul"))
bind->joykey = NO_BTN;
else
{
if (*btn == 'h')
parse_hat(bind, btn + 1);
else
bind->joykey = strtoull(tmp, NULL, 0);
}
}
if (config_get_string(conf, key_label, &tmp_a))
{
strlcpy(bind->joykey_label, tmp_a, sizeof(bind->joykey_label));
free(tmp_a);
}
}
void input_config_parse_key(config_file_t *conf, const char *prefix, const char *btn,
struct retro_keybind *bind)
{
char tmp[64];
char key[64];
snprintf(key, sizeof(key), "%s_%s", prefix, btn);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
bind->key = find_sk_key(tmp);
}
void input_config_parse_key(config_file_t *conf,
const char *prefix, const char *btn,
struct retro_keybind *bind)
{
char tmp[64];
char key[64];
fill_pathname_join_delim(key, prefix, btn, '_', sizeof(key));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
bind->key = input_config_translate_str_to_rk(tmp);
}
void input_config_parse_key(config_file_t *conf,
const char *prefix, const char *btn,
struct retro_keybind *bind)
{
char tmp[64] = {0};
char key[64] = {0};
snprintf(key, sizeof(key), "%s_%s", prefix, btn);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
bind->key = input_translate_str_to_rk(tmp);
}
static void salamander_init(char *s, size_t len)
{
/* normal executable loading path */
bool config_file_exists = false;
if (path_file_exists(g_defaults.path.config))
config_file_exists = true;
if (config_file_exists)
{
char tmp_str[PATH_MAX_LENGTH];
config_file_t * conf = (config_file_t*)config_file_new(g_defaults.path.config);
if (conf)
{
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
if (strcmp(tmp_str, "builtin") != 0)
strlcpy(s, tmp_str, len);
}
#ifdef GEKKO
/* stupid libfat bug or something; sometimes it says
* the file is there when it doesn't. */
else
{
config_file_exists = false;
}
#endif
}
if (!config_file_exists || !strcmp(s, ""))
{
char executable_name[PATH_MAX_LENGTH];
frontend_driver_get_core_extension(
executable_name, sizeof(executable_name));
find_and_set_first_file(s, len, executable_name);
}
else
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", s);
if (!config_file_exists)
{
config_file_t *conf = (config_file_t*)config_file_new(NULL);
if (conf)
{
config_set_string(conf, "libretro_path", s);
config_file_write(conf, g_defaults.path.config);
config_file_free(conf);
}
}
}
static void salamander_init_settings(void)
{
char tmp_str[512] = {0};
bool config_file_exists;
if(!path_file_exists(default_paths.config_path))
{
FILE * f;
config_file_exists = false;
RARCH_ERR("Config file \"%s\" doesn't exist. Creating...\n", default_paths.config_path);
MAKE_DIR(default_paths.port_dir);
f = fopen(default_paths.config_path, "w");
fclose(f);
}
else
config_file_exists = true;
//try to find CORE executable
char core_executable[1024];
snprintf(core_executable, sizeof(core_executable), "%s/CORE.dol", default_paths.core_dir);
if(path_file_exists(core_executable))
{
//Start CORE executable
snprintf(default_paths.libretro_path, sizeof(default_paths.libretro_path), core_executable);
RARCH_LOG("Start [%s].\n", default_paths.libretro_path);
}
else
{
if(config_file_exists)
{
config_file_t * conf = config_file_new(default_paths.config_path);
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
snprintf(default_paths.libretro_path, sizeof(default_paths.libretro_path), tmp_str);
}
if(!config_file_exists || !strcmp(default_paths.libretro_path, ""))
find_and_set_first_file();
else
{
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", default_paths.libretro_path);
}
if (!config_file_exists)
{
config_file_t *new_conf = config_file_new(NULL);
config_set_string(new_conf, "libretro_path", default_paths.libretro_path);
config_file_write(new_conf, default_paths.config_path);
config_file_free(new_conf);
}
}
}
bool config_get_path(config_file_t *conf, const char *key,
char *buf, size_t size)
{
#if defined(RARCH_CONSOLE)
return config_get_array(conf, key, buf, size);
#else
const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
if (entry)
fill_pathname_expand_special(buf, entry->value, size);
return entry != NULL;
#endif
}
static void salamander_init(void)
{
char tmp_str[512] = {0};
bool config_file_exists;
if (path_file_exists(config_path))
config_file_exists = true;
//try to find CORE executable
char core_executable[1024];
fill_pathname_join(core_executable, default_paths.core_dir, "CORE.dol", sizeof(core_executable));
if(path_file_exists(core_executable))
{
//Start CORE executable
strlcpy(libretro_path, core_executable, sizeof(libretro_path));
RARCH_LOG("Start [%s].\n", libretro_path);
}
else
{
if(config_file_exists)
{
config_file_t * conf = config_file_new(config_path);
if (!conf) // stupid libfat bug or something; somtimes it says the file is there when it doesn't
config_file_exists = false;
else
{
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
strlcpy(libretro_path, tmp_str, sizeof(libretro_path));
}
}
if(!config_file_exists || !strcmp(libretro_path, ""))
find_and_set_first_file();
else
{
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path);
}
if (!config_file_exists)
{
config_file_t *new_conf = config_file_new(NULL);
config_set_string(new_conf, "libretro_path", libretro_path);
config_file_write(new_conf, config_path);
config_file_free(new_conf);
}
}
}
static void init_settings(void)
{
char tmp_str[PATH_MAX];
bool config_file_exists;
if(!path_file_exists(SYS_CONFIG_FILE))
{
FILE * f;
config_file_exists = false;
RARCH_ERR("Config file \"%s\" doesn't exist. Creating...\n", SYS_CONFIG_FILE);
f = fopen(SYS_CONFIG_FILE, "w");
fclose(f);
}
else
config_file_exists = true;
//try to find CORE executable
char core_executable[1024];
#if defined(_XBOX)
snprintf(core_executable, sizeof(core_executable), "game:\\CORE.xex");
#elif defined(__CELLOS_LV2__)
snprintf(core_executable, sizeof(core_executable), "%s/CORE.SELF", LIBRETRO_DIR_PATH);
#endif
if(path_file_exists(core_executable))
{
//Start CORE executable
snprintf(libretro_path, sizeof(libretro_path), core_executable);
RARCH_LOG("Start [%s].\n", libretro_path);
}
else
{
if(config_file_exists)
{
config_file_t * conf = config_file_new(SYS_CONFIG_FILE);
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
snprintf(libretro_path, sizeof(libretro_path), tmp_str);
}
if(!config_file_exists || !strcmp(libretro_path, ""))
find_and_set_first_file();
else
{
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path);
}
}
}
bool config_get_path(config_file_t *conf, const char *key,
char *buf, size_t size)
{
#if defined(RARCH_CONSOLE) || !defined(RARCH_INTERNAL)
if (config_get_array(conf, key, buf, size))
return true;
#else
const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
if (entry)
{
fill_pathname_expand_special(buf, entry->value, size);
return true;
}
#endif
return false;
}
static bool create_filter_graph(rarch_dsp_filter_t *dsp, float sample_rate)
{
unsigned i, filters = 0;
if (!config_get_uint(dsp->conf, "filters", &filters))
return false;
dsp->instances = (struct rarch_dsp_instance*)
calloc(filters, sizeof(*dsp->instances));
if (!dsp->instances)
return false;
dsp->num_instances = filters;
for (i = 0; i < filters; i++)
{
struct config_file_userdata userdata;
struct dspfilter_info info;
char key[64] = {0};
char name[64] = {0};
info.input_rate = sample_rate;
snprintf(key, sizeof(key), "filter%u", i);
if (!config_get_array(dsp->conf, key, name, sizeof(name)))
return false;
dsp->instances[i].impl = find_implementation(dsp, name);
if (!dsp->instances[i].impl)
return false;
userdata.conf = dsp->conf;
/* Index-specific configs take priority over ident-specific. */
userdata.prefix[0] = key;
userdata.prefix[1] = dsp->instances[i].impl->short_ident;
dsp->instances[i].impl_data = dsp->instances[i].impl->init(&info, &dspfilter_config, &userdata);
if (!dsp->instances[i].impl_data)
return false;
}
return true;
}
static void salamander_init(char *libretro_path, size_t sizeof_libretro_path)
{
//normal executable loading path
bool config_file_exists = false;
if (path_file_exists(default_paths.config_path))
config_file_exists = true;
if (config_file_exists)
{
char tmp_str[PATH_MAX];
config_file_t * conf = (config_file_t*)config_file_new(default_paths.config_path);
if (conf)
{
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
strlcpy(libretro_path, tmp_str, sizeof_libretro_path);
}
#ifdef GEKKO
else // stupid libfat bug or something; somtimes it says the file is there when it doesn't
config_file_exists = false;
#endif
}
if (!config_file_exists || !strcmp(libretro_path, ""))
find_and_set_first_file(libretro_path, sizeof_libretro_path, EXT_EXECUTABLES);
else
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path);
if (!config_file_exists)
{
config_file_t *conf = (config_file_t*)config_file_new(NULL);
if (conf)
{
config_set_string(conf, "libretro_path", libretro_path);
config_file_write(conf, default_paths.config_path);
config_file_free(conf);
}
}
}
void input_config_parse_joy_axis(void *data, const char *prefix,
const char *axis, struct retro_keybind *bind)
{
char str[256];
char tmp[64];
char key[64];
char key_label[64];
char *tmp_a = NULL;
config_file_t *conf = (config_file_t*)data;
str[0] = tmp[0] = key[0] = key_label[0] = '\0';
fill_pathname_join_delim(str, prefix, axis,
'_', sizeof(str));
fill_pathname_join_delim(key, str,
"axis", '_', sizeof(key));
fill_pathname_join_delim(key_label, str,
"axis_label", '_', sizeof(key_label));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
if (string_is_equal(tmp, file_path_str(FILE_PATH_NUL)))
bind->joyaxis = AXIS_NONE;
else if (strlen(tmp) >= 2 && (*tmp == '+' || *tmp == '-'))
{
int i_axis = strtol(tmp + 1, NULL, 0);
if (*tmp == '+')
bind->joyaxis = AXIS_POS(i_axis);
else
bind->joyaxis = AXIS_NEG(i_axis);
}
/* Ensure that D-pad emulation doesn't screw this over. */
bind->orig_joyaxis = bind->joyaxis;
}
if (config_get_string(conf, key_label, &tmp_a))
{
strlcpy(bind->joyaxis_label, tmp_a, sizeof(bind->joyaxis_label));
free(tmp_a);
}
}
static void salamander_init(char *s, size_t len)
{
/* normal executable loading path */
bool config_file_exists = false;
if (path_file_exists(g_defaults.path.config))
config_file_exists = true;
if (config_file_exists)
{
char tmp_str[PATH_MAX_LENGTH];
config_file_t * conf = (config_file_t*)config_file_new(g_defaults.path.config);
if (conf)
{
config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));
config_file_free(conf);
strlcpy(s, tmp_str, len);
}
#ifdef GEKKO
else /* stupid libfat bug or something; sometimes it says the file is there when it doesn't */
config_file_exists = false;
#endif
}
if (!config_file_exists || !strcmp(s, ""))
find_and_set_first_file(s, len, EXT_EXECUTABLES);
else
RARCH_LOG("Start [%s] found in retroarch.cfg.\n", s);
if (!config_file_exists)
{
config_file_t *conf = (config_file_t*)config_file_new(NULL);
if (conf)
{
config_set_string(conf, "libretro_path", s);
config_file_write(conf, g_defaults.path.config);
config_file_free(conf);
}
}
}
bool config_get_path(config_file_t *conf, const char *key,
char *buf, size_t size)
{
#if defined(RARCH_CONSOLE)
return config_get_array(conf, key, buf, size);
#else
struct config_entry_list *list = conf->entries;
while (list)
{
if (strcmp(key, list->key) == 0)
{
fill_pathname_expand_special(buf, list->value, size);
return true;
}
list = list->next;
}
return false;
#endif
}
void input_config_parse_joy_button(config_file_t *conf, const char *prefix,
const char *btn, struct retro_keybind *bind)
{
char tmp[64];
char key[64];
snprintf(key, sizeof(key), "%s_%s_btn", prefix, btn);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
const char *btn = tmp;
if (strcmp(btn, "nul") == 0)
bind->joykey = NO_BTN;
else
{
if (*btn == 'h')
parse_hat(bind, btn + 1);
else
bind->joykey = strtoull(tmp, NULL, 0);
}
}
}
void input_config_parse_joy_axis(config_file_t *conf, const char *prefix,
const char *axis, struct retro_keybind *bind)
{
char tmp[64];
char key[64];
snprintf(key, sizeof(key), "%s_%s_axis", prefix, axis);
if (config_get_array(conf, key, tmp, sizeof(tmp)))
{
if (strcmp(tmp, "nul") == 0)
bind->joyaxis = AXIS_NONE;
else if (strlen(tmp) >= 2 && (*tmp == '+' || *tmp == '-'))
{
int axis = strtol(tmp + 1, NULL, 0);
if (*tmp == '+')
bind->joyaxis = AXIS_POS(axis);
else
bind->joyaxis = AXIS_NEG(axis);
}
}
}
/**
* video_shader_parse_imports:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Resolves import parameters belonging to shaders.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool video_shader_parse_imports(config_file_t *conf,
struct video_shader *shader)
{
const char *id = NULL;
char *save = NULL;
char imports[1024] = {0};
if (!config_get_array(conf, "imports", imports, sizeof(imports)))
return true;
for (id = strtok_r(imports, ";", &save);
id && shader->variables < GFX_MAX_VARIABLES;
shader->variables++, id = strtok_r(NULL, ";", &save))
{
uint32_t semantic_hash;
char semantic_buf[64] = {0};
char wram_buf[64] = {0};
char input_slot_buf[64] = {0};
char mask_buf[64] = {0};
char equal_buf[64] = {0};
char semantic[64] = {0};
unsigned addr = 0;
unsigned mask = 0;
unsigned equal = 0;
struct state_tracker_uniform_info *var =
&shader->variable[shader->variables];
strlcpy(var->id, id, sizeof(var->id));
snprintf(semantic_buf, sizeof(semantic_buf), "%s_semantic", id);
snprintf(wram_buf, sizeof(wram_buf), "%s_wram", id);
snprintf(input_slot_buf, sizeof(input_slot_buf), "%s_input_slot", id);
snprintf(mask_buf, sizeof(mask_buf), "%s_mask", id);
snprintf(equal_buf, sizeof(equal_buf), "%s_equal", id);
if (!config_get_array(conf, semantic_buf, semantic, sizeof(semantic)))
{
RARCH_ERR("No semantic for import variable.\n");
return false;
}
semantic_hash = djb2_calculate(semantic);
switch (semantic_hash)
{
case SEMANTIC_CAPTURE:
var->type = RARCH_STATE_CAPTURE;
break;
case SEMANTIC_TRANSITION:
var->type = RARCH_STATE_TRANSITION;
break;
case SEMANTIC_TRANSITION_COUNT:
var->type = RARCH_STATE_TRANSITION_COUNT;
break;
case SEMANTIC_CAPTURE_PREVIOUS:
var->type = RARCH_STATE_CAPTURE_PREV;
break;
case SEMANTIC_TRANSITION_PREVIOUS:
var->type = RARCH_STATE_TRANSITION_PREV;
break;
case SEMANTIC_PYTHON:
var->type = RARCH_STATE_PYTHON;
break;
default:
RARCH_ERR("Invalid semantic.\n");
return false;
}
if (var->type != RARCH_STATE_PYTHON)
{
unsigned input_slot = 0;
if (config_get_uint(conf, input_slot_buf, &input_slot))
{
switch (input_slot)
{
case 1:
var->ram_type = RARCH_STATE_INPUT_SLOT1;
break;
case 2:
var->ram_type = RARCH_STATE_INPUT_SLOT2;
break;
default:
RARCH_ERR("Invalid input slot for import.\n");
return false;
}
}
else if (config_get_hex(conf, wram_buf, &addr))
{
var->ram_type = RARCH_STATE_WRAM;
var->addr = addr;
}
else
{
RARCH_ERR("No address assigned to semantic.\n");
return false;
}
}
if (config_get_hex(conf, mask_buf, &mask))
var->mask = mask;
if (config_get_hex(conf, equal_buf, &equal))
var->equal = equal;
}
config_get_path(conf, "import_script",
shader->script_path, sizeof(shader->script_path));
config_get_array(conf, "import_script_class",
shader->script_class, sizeof(shader->script_class));
return true;
}