void rarch_set_paths(const char *path)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
set_basename(path);
if (!global->has_set_save_path)
fill_pathname_noext(global->savefile_name, global->basename,
".srm", sizeof(global->savefile_name));
if (!global->has_set_state_path)
fill_pathname_noext(global->savestate_name, global->basename,
".state", sizeof(global->savestate_name));
fill_pathname_noext(global->cheatfile_name, global->basename,
".cht", sizeof(global->cheatfile_name));
set_paths_redirect(path);
/* If this is already set, do not overwrite it
* as this was initialized before in a menu or otherwise. */
if (*settings->system_directory)
return;
fill_pathname_basedir(settings->system_directory, path,
sizeof(settings->system_directory));
}
static bool take_screenshot_raw(const char *global_name_base)
{
unsigned width, height;
size_t pitch;
char screenshot_path[PATH_MAX_LENGTH] = {0};
const void *data = NULL;
settings_t *settings = config_get_ptr();
const char *screenshot_dir = settings->directory.screenshot;
video_driver_cached_frame_get(&data, &width, &height, &pitch);
if (string_is_empty(settings->directory.screenshot))
{
fill_pathname_basedir(screenshot_path, global_name_base,
sizeof(screenshot_path));
screenshot_dir = screenshot_path;
}
/* Negative pitch is needed as screenshot takes bottom-up,
* but we use top-down.
*/
if (!screenshot_dump(global_name_base, screenshot_dir,
(const uint8_t*)data + (height - 1) * pitch,
width, height, -pitch, false))
return false;
return true;
}
static void get_environment_settings(int argc, char *argv[])
{
(void)argc;
(void)argv;
#ifdef HAVE_FILE_LOGGER
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
fill_pathname_basedir(default_paths.port_dir, argv[0], sizeof(default_paths.port_dir));
RARCH_LOG("port dir: [%s]\n", default_paths.port_dir);
snprintf(default_paths.core_dir, sizeof(default_paths.core_dir), "%s/cores", default_paths.port_dir);
snprintf(default_paths.executable_extension, sizeof(default_paths.executable_extension), ".SELF");
snprintf(default_paths.savestate_dir, sizeof(default_paths.savestate_dir), "%s/savestates", default_paths.core_dir);
snprintf(default_paths.filesystem_root_dir, sizeof(default_paths.filesystem_root_dir), "/");
snprintf(default_paths.filebrowser_startup_dir, sizeof(default_paths.filebrowser_startup_dir), default_paths.filesystem_root_dir);
snprintf(default_paths.sram_dir, sizeof(default_paths.sram_dir), "%s/sram", default_paths.core_dir);
snprintf(default_paths.system_dir, sizeof(default_paths.system_dir), "%s/system", default_paths.core_dir);
/* now we fill in all the variables */
snprintf(default_paths.border_file, sizeof(default_paths.border_file), "%s/borders/Centered-1080p/mega-man-2.png", default_paths.core_dir);
snprintf(default_paths.menu_border_file, sizeof(default_paths.menu_border_file), "%s/borders/Menu/main-menu.png", default_paths.core_dir);
snprintf(default_paths.cgp_dir, sizeof(default_paths.cgp_dir), "%s/presets", default_paths.core_dir);
snprintf(default_paths.input_presets_dir, sizeof(default_paths.input_presets_dir), "%s/input", default_paths.cgp_dir);
snprintf(default_paths.border_dir, sizeof(default_paths.border_dir), "%s/borders", default_paths.core_dir);
snprintf(g_extern.config_path, sizeof(g_extern.config_path), "%s/retroarch.cfg", default_paths.port_dir);
snprintf(default_paths.salamander_file, sizeof(default_paths.salamander_file), "EBOOT.BIN");
}
static void get_environment_settings(int argc, char *argv[])
{
#ifndef IS_SALAMANDER
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
#endif
fill_pathname_basedir(default_paths.port_dir, argv[0], sizeof(default_paths.port_dir));
RARCH_LOG("port dir: [%s]\n", default_paths.port_dir);
snprintf(default_paths.core_dir, sizeof(default_paths.core_dir), "%s/cores", default_paths.port_dir);
snprintf(default_paths.savestate_dir, sizeof(default_paths.savestate_dir), "%s/savestates", default_paths.core_dir);
snprintf(default_paths.filesystem_root_dir, sizeof(default_paths.filesystem_root_dir), "/");
snprintf(default_paths.filebrowser_startup_dir, sizeof(default_paths.filebrowser_startup_dir), default_paths.filesystem_root_dir);
snprintf(default_paths.sram_dir, sizeof(default_paths.sram_dir), "%s/savefiles", default_paths.core_dir);
snprintf(default_paths.system_dir, sizeof(default_paths.system_dir), "%s/system", default_paths.core_dir);
/* now we fill in all the variables */
snprintf(default_paths.menu_border_file, sizeof(default_paths.menu_border_file), "%s/borders/Menu/main-menu.png", default_paths.core_dir);
snprintf(default_paths.border_dir, sizeof(default_paths.border_dir), "%s/borders", default_paths.core_dir);
snprintf(g_extern.config_path, sizeof(g_extern.config_path), "%s/retroarch.cfg", default_paths.port_dir);
}
rarch_softfilter_t *rarch_softfilter_new(const char *filter_config,
unsigned threads,
enum retro_pixel_format in_pixel_format,
unsigned max_width, unsigned max_height)
{
softfilter_simd_mask_t cpu_features = retro_get_cpu_features();
char basedir[PATH_MAX_LENGTH] = {0};
struct string_list *plugs = NULL;
rarch_softfilter_t *filt = NULL;
(void)basedir;
filt = (rarch_softfilter_t*)calloc(1, sizeof(*filt));
if (!filt)
return NULL;
filt->conf = config_file_new(filter_config);
if (!filt->conf)
{
RARCH_ERR("[SoftFilter]: Did not find config: %s\n", filter_config);
goto error;
}
#if defined(HAVE_DYLIB)
fill_pathname_basedir(basedir, filter_config, sizeof(basedir));
plugs = dir_list_new(basedir, EXT_EXECUTABLES, false, false);
if (!plugs)
{
RARCH_ERR("[SoftFilter]: Could not build up string list...\n");
goto error;
}
#endif
if (!append_softfilter_plugs(filt, plugs))
{
RARCH_ERR("[SoftFitler]: Failed to append softfilter plugins...\n");
goto error;
}
if (plugs)
string_list_free(plugs);
plugs = NULL;
if (!create_softfilter_graph(filt, in_pixel_format,
max_width, max_height, cpu_features, threads))
{
RARCH_ERR("[SoftFitler]: Failed to create softfilter graph...\n");
goto error;
}
return filt;
error:
if (plugs)
string_list_free(plugs);
plugs = NULL;
rarch_softfilter_free(filt);
return NULL;
}
static void frontend_psp_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
(void)args;
#ifndef IS_SALAMANDER
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
#endif
strlcpy(eboot_path, argv[0], sizeof(eboot_path));
fill_pathname_basedir(g_defaults.port_dir, argv[0], sizeof(g_defaults.port_dir));
RARCH_LOG("port dir: [%s]\n", g_defaults.port_dir);
fill_pathname_join(g_defaults.assets_dir, g_defaults.port_dir, "media", sizeof(g_defaults.assets_dir));
fill_pathname_join(g_defaults.core_dir, g_defaults.port_dir, "cores", sizeof(g_defaults.core_dir));
fill_pathname_join(g_defaults.core_info_dir, g_defaults.port_dir, "cores", sizeof(g_defaults.core_info_dir));
fill_pathname_join(g_defaults.savestate_dir, g_defaults.core_dir, "savestates", sizeof(g_defaults.savestate_dir));
fill_pathname_join(g_defaults.sram_dir, g_defaults.core_dir, "savefiles", sizeof(g_defaults.sram_dir));
fill_pathname_join(g_defaults.system_dir, g_defaults.core_dir, "system", sizeof(g_defaults.system_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.port_dir, "retroarch.cfg", sizeof(g_defaults.config_path));
if (argv[1] && (argv[1][0] != '\0'))
{
static char path[PATH_MAX];
*path = '\0';
struct rarch_main_wrap *args = (struct rarch_main_wrap*)params_data;
if (args)
{
strlcpy(path, argv[1], sizeof(path));
args->touched = true;
args->no_rom = false;
args->verbose = false;
args->config_path = NULL;
args->sram_path = NULL;
args->state_path = NULL;
args->rom_path = path;
args->libretro_path = NULL;
RARCH_LOG("argv[0]: %s\n", argv[0]);
RARCH_LOG("argv[1]: %s\n", argv[1]);
RARCH_LOG("argv[2]: %s\n", argv[2]);
RARCH_LOG("Auto-start game %s.\n", argv[1]);
}
}
}
static void event_set_savestate_auto_index(void)
{
size_t i;
char state_dir[PATH_MAX_LENGTH] = {0};
char state_base[PATH_MAX_LENGTH] = {0};
struct string_list *dir_list = NULL;
unsigned max_idx = 0;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
if (!settings->savestate_auto_index)
return;
/* Find the file in the same directory as global->savestate_name
* with the largest numeral suffix.
*
* E.g. /foo/path/content.state, will try to find
* /foo/path/content.state%d, where %d is the largest number available.
*/
fill_pathname_basedir(state_dir, global->savestate_name,
sizeof(state_dir));
fill_pathname_base(state_base, global->savestate_name,
sizeof(state_base));
if (!(dir_list = dir_list_new_special(state_dir, DIR_LIST_PLAIN)))
return;
for (i = 0; i < dir_list->size; i++)
{
unsigned idx;
char elem_base[PATH_MAX_LENGTH] = {0};
const char *end = NULL;
const char *dir_elem = dir_list->elems[i].data;
fill_pathname_base(elem_base, dir_elem, sizeof(elem_base));
if (strstr(elem_base, state_base) != elem_base)
continue;
end = dir_elem + strlen(dir_elem);
while ((end > dir_elem) && isdigit(end[-1]))
end--;
idx = strtoul(end, NULL, 0);
if (idx > max_idx)
max_idx = idx;
}
dir_list_free(dir_list);
settings->state_slot = max_idx;
RARCH_LOG("Found last state slot: #%d\n", settings->state_slot);
}
/**
* fill_pathname_resolve_relative:
* @out_path : output path
* @in_refpath : input reference path
* @in_path : input path
* @size : size of @out_path
*
* Joins basedir of @in_refpath together with @in_path.
* If @in_path is an absolute path, out_path = in_path.
* E.g.: in_refpath = "/foo/bar/baz.a", in_path = "foobar.cg",
* out_path = "/foo/bar/foobar.cg".
**/
void fill_pathname_resolve_relative(char *out_path,
const char *in_refpath, const char *in_path, size_t size)
{
if (path_is_absolute(in_path))
{
retro_assert(strlcpy(out_path, in_path, size) < size);
return;
}
fill_pathname_basedir(out_path, in_refpath, size);
retro_assert(strlcat(out_path, in_path, size) < size);
}
/**
* rarch_game_specific_options:
* @cmd : Output variable with path to core options file.
*
* Environment callback function implementation.
*
* Returns: true (1) if a game specific core options path has been found,
* otherwise false (0).
**/
static bool rarch_game_specific_options(char **output)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
const char *core_name = NULL;
const char *game_name = NULL;
config_file_t *option_file = NULL;
char game_path[PATH_MAX_LENGTH] = {0};
char config_directory[PATH_MAX_LENGTH] = {0};
core_name = system ? system->info.library_name : NULL;
game_name = global ? path_basename(global->name.base) : NULL;
if (!core_name || !game_name)
return false;
if (core_name[0] == '\0' || game_name[0] == '\0')
return false;
RARCH_LOG("Per-Game Options: core name: %s\n", core_name);
RARCH_LOG("Per-Game Options: game name: %s\n", game_name);
/* Config directory: config_directory.
* Try config directory setting first,
* fallback to the location of the current configuration file. */
if (settings->menu_config_directory[0] != '\0')
strlcpy(config_directory, settings->menu_config_directory, PATH_MAX_LENGTH);
else if (global->path.config[0] != '\0')
fill_pathname_basedir(config_directory, global->path.config, PATH_MAX_LENGTH);
else
{
RARCH_WARN("Per-Game Options: no config directory set\n");
return false;
}
/* Concatenate strings into full paths for game_path */
fill_pathname_join(game_path, config_directory, core_name, PATH_MAX_LENGTH);
fill_pathname_join(game_path, game_path, game_name, PATH_MAX_LENGTH);
strlcat(game_path, ".opt", PATH_MAX_LENGTH);
option_file = config_file_new(game_path);
if (!option_file)
return false;
config_file_free(option_file);
RARCH_LOG("Per-Game Options: game-specific core options found at %s\n", game_path);
*output = strdup(game_path);
return true;
}
static bool zlib_cb(const char *name, const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size,
uint32_t crc32, void *userdata)
{
struct userdata *user = userdata;
const char *subdir = user->subdir;
const char *dest = user->dest;
if (strstr(name, subdir) != name)
return true;
name += strlen(subdir) + 1;
char path[PATH_MAX];
char path_dir[PATH_MAX];
fill_pathname_join(path, dest, name, sizeof(path));
fill_pathname_basedir(path_dir, path, sizeof(path_dir));
if (!path_mkdir(path_dir))
{
RARCH_ERR("Failed to create dir: %s.\n", path_dir);
return false;
}
RARCH_LOG("Extracting %s -> %s ...\n", name, path);
switch (cmode)
{
case 0: // Uncompressed
if (!write_file(path, cdata, size))
{
RARCH_ERR("Failed to write file: %s.\n", path);
return false;
}
break;
case 8: // Deflate
if (!zlib_inflate_data_to_file(path, cdata, csize, size, crc32))
{
RARCH_ERR("Failed to deflate to: %s.\n", path);
return false;
}
break;
default:
return false;
}
return true;
}
void rarch_console_load_game_wrap(const char *path, unsigned extract_zip_mode, unsigned delay)
{
const char *game_to_load;
char first_file_inzip[PATH_MAX];
char rom_path_temp[PATH_MAX];
char dir_path_temp[PATH_MAX];
struct retro_system_info info;
bool block_zip_extract = false;
bool extract_zip_cond = false;
bool extract_zip_and_load_game_cond = false;
bool load_game = !extract_zip_cond;
retro_get_system_info(&info);
block_zip_extract = info.block_extract;
snprintf(rom_path_temp, sizeof(rom_path_temp), path);
#ifdef HAVE_ZLIB
extract_zip_cond = (strstr(rom_path_temp, ".zip") || strstr(rom_path_temp, ".ZIP"))
&& !block_zip_extract;
if(extract_zip_cond)
{
fill_pathname_basedir(dir_path_temp, rom_path_temp, sizeof(dir_path_temp));
rarch_extract_zipfile(rom_path_temp, dir_path_temp, first_file_inzip, sizeof(first_file_inzip), extract_zip_mode);
if(g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_EXTRACTED_ZIPFILE, S_DELAY_180);
}
extract_zip_and_load_game_cond = (extract_zip_cond &&
g_extern.file_state.zip_extract_mode == ZIP_EXTRACT_TO_CURRENT_DIR_AND_LOAD_FIRST_FILE);
load_game = (extract_zip_and_load_game_cond) || (!extract_zip_cond);
if(extract_zip_and_load_game_cond)
game_to_load = first_file_inzip;
else
#endif
game_to_load = path;
if(load_game)
{
rarch_console_load_game(game_to_load);
if(g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_LOADING_ROM, delay);
}
}
rarch_dsp_filter_t *rarch_dsp_filter_new(
const char *filter_config, float sample_rate)
{
char basedir[PATH_MAX_LENGTH] = {0};
struct string_list *plugs = NULL;
rarch_dsp_filter_t *dsp = NULL;
(void)basedir;
dsp = (rarch_dsp_filter_t*)calloc(1, sizeof(*dsp));
if (!dsp)
return NULL;
dsp->conf = config_file_new(filter_config);
if (!dsp->conf) /* Did not find config. */
goto error;
#if !defined(HAVE_FILTERS_BUILTIN) && defined(HAVE_DYLIB)
fill_pathname_basedir(basedir, filter_config, sizeof(basedir));
plugs = dir_list_new(basedir, EXT_EXECUTABLES, false, false);
if (!plugs)
goto error;
#endif
#if defined(HAVE_DYLIB) || defined(HAVE_FILTERS_BUILTIN)
if (!append_plugs(dsp, plugs))
goto error;
#endif
if (plugs)
string_list_free(plugs);
plugs = NULL;
if (!create_filter_graph(dsp, sample_rate))
goto error;
return dsp;
error:
if (plugs)
string_list_free(plugs);
rarch_dsp_filter_free(dsp);
return NULL;
}
static void frontend_wiiu_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
unsigned i;
(void)args;
fill_pathname_basedir(g_defaults.dirs[DEFAULT_DIR_PORT], elf_path_cst, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT],
"downloads", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT],
"media", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE], g_defaults.dirs[DEFAULT_DIR_PORT],
"cores", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_CORE],
"info", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SAVESTATE], g_defaults.dirs[DEFAULT_DIR_CORE],
"savestates", sizeof(g_defaults.dirs[DEFAULT_DIR_SAVESTATE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SRAM], g_defaults.dirs[DEFAULT_DIR_CORE],
"savefiles", sizeof(g_defaults.dirs[DEFAULT_DIR_SRAM]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SYSTEM], g_defaults.dirs[DEFAULT_DIR_CORE],
"system", sizeof(g_defaults.dirs[DEFAULT_DIR_SYSTEM]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_PLAYLIST], g_defaults.dirs[DEFAULT_DIR_CORE],
"playlists", sizeof(g_defaults.dirs[DEFAULT_DIR_PLAYLIST]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], g_defaults.dirs[DEFAULT_DIR_PORT],
"config", sizeof(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_REMAP], g_defaults.dirs[DEFAULT_DIR_PORT],
"config/remaps", sizeof(g_defaults.dirs[DEFAULT_DIR_REMAP]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER], g_defaults.dirs[DEFAULT_DIR_PORT],
"filters", sizeof(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_DATABASE], g_defaults.dirs[DEFAULT_DIR_PORT],
"database/rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CURSOR], g_defaults.dirs[DEFAULT_DIR_PORT],
"database/cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR]));
fill_pathname_join(g_defaults.path.config, g_defaults.dirs[DEFAULT_DIR_PORT],
file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config));
for (i = 0; i < DEFAULT_DIR_LAST; i++)
{
const char *dir_path = g_defaults.dirs[i];
if (!string_is_empty(dir_path))
path_mkdir(dir_path);
}
}
static void config_load_core_specific(void)
{
*g_extern.core_specific_config_path = '\0';
if (!*g_settings.libretro
#ifdef HAVE_DYNAMIC
|| g_extern.libretro_dummy
#endif
)
return;
#ifdef HAVE_MENU
if (*g_settings.rgui_config_directory)
{
path_resolve_realpath(g_settings.rgui_config_directory, sizeof(g_settings.rgui_config_directory));
strlcpy(g_extern.core_specific_config_path, g_settings.rgui_config_directory, sizeof(g_extern.core_specific_config_path));
}
else
#endif
{
// Use original config file's directory as a fallback.
fill_pathname_basedir(g_extern.core_specific_config_path, g_extern.config_path, sizeof(g_extern.core_specific_config_path));
}
fill_pathname_dir(g_extern.core_specific_config_path, g_settings.libretro, ".cfg", sizeof(g_extern.core_specific_config_path));
if (g_settings.core_specific_config)
{
char tmp[PATH_MAX];
strlcpy(tmp, g_settings.libretro, sizeof(tmp));
RARCH_LOG("Loading core-specific config from: %s.\n", g_extern.core_specific_config_path);
if (!config_load_file(g_extern.core_specific_config_path, true))
RARCH_WARN("Core-specific config not found, reusing last config.\n");
// Force some parameters which are implied when using core specific configs.
// Don't have the core config file overwrite the libretro path.
strlcpy(g_settings.libretro, tmp, sizeof(g_settings.libretro));
// This must be true for core specific configs.
g_settings.core_specific_config = true;
}
}
static bool take_screenshot_viewport(const char *global_name_base)
{
char screenshot_path[PATH_MAX_LENGTH] = {0};
const char *screenshot_dir = NULL;
uint8_t *buffer = NULL;
bool retval = false;
struct video_viewport vp = {0};
settings_t *settings = config_get_ptr();
video_driver_get_viewport_info(&vp);
if (!vp.width || !vp.height)
return false;
buffer = (uint8_t*)malloc(vp.width * vp.height * 3);
if (!buffer)
return false;
if (!video_driver_read_viewport(buffer))
goto done;
screenshot_dir = settings->directory.screenshot;
if (string_is_empty(screenshot_dir))
{
fill_pathname_basedir(screenshot_path, global_name_base,
sizeof(screenshot_path));
screenshot_dir = screenshot_path;
}
/* Data read from viewport is in bottom-up order, suitable for BMP. */
if (!screenshot_dump(global_name_base, screenshot_dir, buffer, vp.width, vp.height,
vp.width * 3, true))
goto done;
retval = true;
done:
if (buffer)
free(buffer);
return retval;
}
static int file_decompressed_subdir(const char *name,
const char *valid_exts,
const uint8_t *cdata,
unsigned cmode, uint32_t csize,uint32_t size,
uint32_t crc32, void *userdata)
{
char path[PATH_MAX_LENGTH];
char path_dir[PATH_MAX_LENGTH];
decompress_state_t *dec = (decompress_state_t*)userdata;
/* Ignore directories. */
if (name[strlen(name) - 1] == '/' || name[strlen(name) - 1] == '\\')
goto next_file;
if (strstr(name, dec->subdir) != name)
return 1;
name += strlen(dec->subdir) + 1;
fill_pathname_join(path, dec->target_dir, name, sizeof(path));
fill_pathname_basedir(path_dir, path, sizeof(path_dir));
/* Make directory */
if (!path_mkdir(path_dir))
goto error;
if (!file_archive_perform_mode(path, valid_exts,
cdata, cmode, csize, size, crc32, userdata))
goto error;
RARCH_LOG("[deflate subdir] Path: %s, CRC32: 0x%x\n", name, crc32);
next_file:
return 1;
error:
dec->callback_error = (char*)malloc(PATH_MAX_LENGTH);
snprintf(dec->callback_error,
PATH_MAX_LENGTH, "Failed to deflate %s.\n", path);
return 0;
}
static void set_special_paths(char **argv, unsigned num_content)
{
unsigned i;
union string_list_elem_attr attr;
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
/* First content file is the significant one. */
set_basename(argv[0]);
global->subsystem_fullpaths = string_list_new();
rarch_assert(global->subsystem_fullpaths);
attr.i = 0;
for (i = 0; i < num_content; i++)
string_list_append(global->subsystem_fullpaths, argv[i], attr);
/* We defer SRAM path updates until we can resolve it.
* It is more complicated for special content types. */
if (!global->has_set_state_path)
fill_pathname_noext(global->savestate_name, global->basename,
".state", sizeof(global->savestate_name));
if (path_is_directory(global->savestate_name))
{
fill_pathname_dir(global->savestate_name, global->basename,
".state", sizeof(global->savestate_name));
RARCH_LOG("Redirecting save state to \"%s\".\n",
global->savestate_name);
}
/* If this is already set,
* do not overwrite it as this was initialized before in
* a menu or otherwise. */
if (!*settings->system_directory)
fill_pathname_basedir(settings->system_directory, argv[0],
sizeof(settings->system_directory));
}
static void frontend_wiiu_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
(void)args;
DEBUG_LINE();
fill_pathname_basedir(g_defaults.dir.port, elf_path_cst, sizeof(g_defaults.dir.port));
DEBUG_LINE();
RARCH_LOG("port dir: [%s]\n", g_defaults.dir.port);
fill_pathname_join(g_defaults.dir.core_assets, g_defaults.dir.port,
"downloads", sizeof(g_defaults.dir.core_assets));
fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port,
"media", sizeof(g_defaults.dir.assets));
fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port,
"cores", sizeof(g_defaults.dir.core));
fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.core,
"info", sizeof(g_defaults.dir.core_info));
fill_pathname_join(g_defaults.dir.savestate, g_defaults.dir.core,
"savestates", sizeof(g_defaults.dir.savestate));
fill_pathname_join(g_defaults.dir.sram, g_defaults.dir.core,
"savefiles", sizeof(g_defaults.dir.sram));
fill_pathname_join(g_defaults.dir.system, g_defaults.dir.core,
"system", sizeof(g_defaults.dir.system));
fill_pathname_join(g_defaults.dir.playlist, g_defaults.dir.core,
"playlists", sizeof(g_defaults.dir.playlist));
fill_pathname_join(g_defaults.dir.menu_config, g_defaults.dir.port,
"config", sizeof(g_defaults.dir.menu_config));
fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.port,
"config/remaps", sizeof(g_defaults.dir.remap));
fill_pathname_join(g_defaults.dir.video_filter, g_defaults.dir.port,
"filters", sizeof(g_defaults.dir.remap));
fill_pathname_join(g_defaults.dir.database, g_defaults.dir.port,
"database/rdb", sizeof(g_defaults.dir.database));
fill_pathname_join(g_defaults.dir.cursor, g_defaults.dir.port,
"database/cursors", sizeof(g_defaults.dir.cursor));
fill_pathname_join(g_defaults.path.config, g_defaults.dir.port,
file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config));
}
static void frontend_psp_get_environment_settings(int argc, char *argv[], void *args)
{
(void)args;
#ifndef IS_SALAMANDER
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
#endif
fill_pathname_basedir(default_paths.port_dir, argv[0], sizeof(default_paths.port_dir));
RARCH_LOG("port dir: [%s]\n", default_paths.port_dir);
fill_pathname_join(default_paths.core_dir, default_paths.port_dir, "cores", sizeof(default_paths.core_dir));
fill_pathname_join(default_paths.savestate_dir, default_paths.core_dir, "savestates", sizeof(default_paths.savestate_dir));
fill_pathname_join(default_paths.sram_dir, default_paths.core_dir, "savefiles", sizeof(default_paths.sram_dir));
fill_pathname_join(default_paths.system_dir, default_paths.core_dir, "system", sizeof(default_paths.system_dir));
/* now we fill in all the variables */
fill_pathname_join(g_extern.config_path, default_paths.port_dir, "retroarch.cfg", sizeof(g_extern.config_path));
}
/**
* event_save_core_config:
*
* Saves a new (core) configuration to a file. Filename is based
* on heuristics to avoid typing.
*
* Returns: true (1) on success, otherwise false (0).
**/
static bool event_save_core_config(void)
{
char config_dir[PATH_MAX_LENGTH] = {0};
char config_name[PATH_MAX_LENGTH] = {0};
char config_path[PATH_MAX_LENGTH] = {0};
char msg[PATH_MAX_LENGTH] = {0};
bool ret = false;
bool found_path = false;
bool overrides_active = false;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
*config_dir = '\0';
if (*settings->menu_config_directory)
strlcpy(config_dir, settings->menu_config_directory,
sizeof(config_dir));
else if (*global->config_path) /* Fallback */
fill_pathname_basedir(config_dir, global->config_path,
sizeof(config_dir));
else
{
const char *message = "Config directory not set. Cannot save new config.";
rarch_main_msg_queue_push(message, 1, 180, true);
RARCH_ERR("%s\n", message);
return false;
}
/* Infer file name based on libretro core. */
if (*settings->libretro && path_file_exists(settings->libretro))
{
unsigned i;
/* In case of collision, find an alternative name. */
for (i = 0; i < 16; i++)
{
char tmp[64] = {0};
fill_pathname_base(config_name, settings->libretro,
sizeof(config_name));
path_remove_extension(config_name);
fill_pathname_join(config_path, config_dir, config_name,
sizeof(config_path));
*tmp = '\0';
if (i)
snprintf(tmp, sizeof(tmp), "-%u.cfg", i);
else
strlcpy(tmp, ".cfg", sizeof(tmp));
strlcat(config_path, tmp, sizeof(config_path));
if (!path_file_exists(config_path))
{
found_path = true;
break;
}
}
}
/* Fallback to system time... */
if (!found_path)
{
RARCH_WARN("Cannot infer new config path. Use current time.\n");
fill_dated_filename(config_name, "cfg", sizeof(config_name));
fill_pathname_join(config_path, config_dir, config_name,
sizeof(config_path));
}
/* Overrides block config file saving, make it appear as overrides weren't enabled for a manual save */
if (global->overrides_active)
{
global->overrides_active = false;
overrides_active = true;
}
if ((ret = config_save_file(config_path)))
{
strlcpy(global->config_path, config_path,
sizeof(global->config_path));
snprintf(msg, sizeof(msg), "Saved new config to \"%s\".",
config_path);
RARCH_LOG("%s\n", msg);
}
else
{
snprintf(msg, sizeof(msg), "Failed saving config to \"%s\".",
config_path);
RARCH_ERR("%s\n", msg);
}
rarch_main_msg_queue_push(msg, 1, 180, true);
global->overrides_active = overrides_active;
return ret;
}
static config_file_t *open_default_config_file(void)
{
config_file_t *conf = NULL;
#if defined(_WIN32) && !defined(_XBOX)
char conf_path[PATH_MAX];
char app_path[PATH_MAX];
fill_pathname_application_path(app_path, sizeof(app_path));
fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path));
conf = config_file_new(conf_path);
if (!conf)
{
const char *appdata = getenv("APPDATA");
if (appdata)
{
fill_pathname_join(conf_path, appdata, "retroarch.cfg", sizeof(conf_path));
conf = config_file_new(conf_path);
}
}
// Try to create a new config file.
if (!conf)
{
conf = config_file_new(NULL);
bool saved = false;
if (conf) // Since this is a clean config file, we can safely use config_save_on_exit.
{
fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path));
config_set_bool(conf, "config_save_on_exit", true);
saved = config_file_write(conf, conf_path);
}
if (saved)
RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it.
else
{
RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path);
config_file_free(conf);
conf = NULL;
}
}
if (conf)
strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path));
#elif !defined(__CELLOS_LV2__) && !defined(_XBOX)
char conf_path[PATH_MAX];
const char *xdg = getenv("XDG_CONFIG_HOME");
const char *home = getenv("HOME");
// XDG_CONFIG_HOME falls back to $HOME/.config.
if (xdg)
fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path));
else if (home)
fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path));
if (xdg || home)
{
RARCH_LOG("Looking for config in: \"%s\".\n", conf_path);
conf = config_file_new(conf_path);
}
// Fallback to $HOME/.retroarch.cfg.
if (!conf && home)
{
fill_pathname_join(conf_path, home, ".retroarch.cfg", sizeof(conf_path));
RARCH_LOG("Looking for config in: \"%s\".\n", conf_path);
conf = config_file_new(conf_path);
}
// Try to create a new config file.
if (!conf && (home || xdg))
{
// XDG_CONFIG_HOME falls back to $HOME/.config.
if (xdg)
fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path));
else if (home)
fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path));
char basedir[PATH_MAX];
fill_pathname_basedir(basedir, conf_path, sizeof(basedir));
if (path_mkdir(basedir))
{
#ifndef GLOBAL_CONFIG_DIR
#define GLOBAL_CONFIG_DIR "/etc"
#endif
char skeleton_conf[PATH_MAX];
fill_pathname_join(skeleton_conf, GLOBAL_CONFIG_DIR, "retroarch.cfg", sizeof(skeleton_conf));
conf = config_file_new(skeleton_conf);
if (conf)
RARCH_WARN("Using skeleton config \"%s\" as base for a new config file.\n", skeleton_conf);
else
conf = config_file_new(NULL);
bool saved = false;
if (conf)
{
config_set_bool(conf, "config_save_on_exit", true); // Since this is a clean config file, we can safely use config_save_on_exit.
saved = config_file_write(conf, conf_path);
}
if (saved)
RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it.
else
{
RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path);
config_file_free(conf);
conf = NULL;
}
}
}
if (conf)
strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path));
#endif
return conf;
}
static void frontend_ctr_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
(void)args;
// return;
#ifndef IS_SALAMANDER
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
global_t *global = global_get_ptr();
global->log_file = fopen("sdmc:/retroarch/retroarch-log.txt", "w");
#endif
#endif
// strlcpy(elf_path, argv[0], sizeof(elf_path));
// fill_pathname_basedir(g_defaults.port_dir, argv[0], sizeof(g_defaults.port_dir));
fill_pathname_basedir(g_defaults.port_dir, elf_path_cst, sizeof(g_defaults.port_dir));
RARCH_LOG("port dir: [%s]\n", g_defaults.port_dir);
fill_pathname_join(g_defaults.assets_dir, g_defaults.port_dir,
"media", sizeof(g_defaults.assets_dir));
fill_pathname_join(g_defaults.core_dir, g_defaults.port_dir,
"cores", sizeof(g_defaults.core_dir));
fill_pathname_join(g_defaults.core_info_dir, g_defaults.port_dir,
"cores", sizeof(g_defaults.core_info_dir));
fill_pathname_join(g_defaults.savestate_dir, g_defaults.core_dir,
"savestates", sizeof(g_defaults.savestate_dir));
fill_pathname_join(g_defaults.sram_dir, g_defaults.core_dir,
"savefiles", sizeof(g_defaults.sram_dir));
fill_pathname_join(g_defaults.system_dir, g_defaults.core_dir,
"system", sizeof(g_defaults.system_dir));
fill_pathname_join(g_defaults.playlist_dir, g_defaults.core_dir,
"playlists", sizeof(g_defaults.playlist_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.port_dir,
"retroarch.cfg", sizeof(g_defaults.config_path));
#ifndef IS_SALAMANDER
// if (argv[1] && (argv[1][0] != '\0'))
// {
// static char path[PATH_MAX_LENGTH];
// struct rarch_main_wrap *args = NULL;
// *path = '\0';
// args = (struct rarch_main_wrap*)params_data;
// if (args)
// {
// strlcpy(path, argv[1], sizeof(path));
// args->touched = true;
// args->no_content = false;
// args->verbose = false;
// args->config_path = NULL;
// args->sram_path = NULL;
// args->state_path = NULL;
// args->content_path = path;
// args->libretro_path = NULL;
// RARCH_LOG("argv[0]: %s\n", argv[0]);
// RARCH_LOG("argv[1]: %s\n", argv[1]);
// RARCH_LOG("argv[2]: %s\n", argv[2]);
// RARCH_LOG("Auto-start game %s.\n", argv[1]);
// }
// }
#endif
}
static bool load_content_from_compressed_archive(
content_information_ctx_t *content_ctx,
struct retro_game_info *info,
unsigned i,
struct string_list* additional_path_allocs,
bool need_fullpath,
const char *path,
char **error_string)
{
union string_list_elem_attr attributes;
char new_path[PATH_MAX_LENGTH];
char new_basedir[PATH_MAX_LENGTH];
ssize_t new_path_len = 0;
bool ret = false;
RARCH_LOG("Compressed file in case of need_fullpath."
" Now extracting to temporary directory.\n");
strlcpy(new_basedir, content_ctx->directory_cache,
sizeof(new_basedir));
if (string_is_empty(new_basedir) || !path_is_directory(new_basedir))
{
RARCH_WARN("Tried extracting to cache directory, but "
"cache directory was not set or found. "
"Setting cache directory to directory "
"derived by basename...\n");
fill_pathname_basedir(new_basedir, path,
sizeof(new_basedir));
}
new_path[0] = '\0';
new_basedir[0] = '\0';
attributes.i = 0;
fill_pathname_join(new_path, new_basedir,
path_basename(path), sizeof(new_path));
ret = file_archive_compressed_read(path, NULL, new_path, &new_path_len);
if (!ret || new_path_len < 0)
{
char str[1024];
snprintf(str, sizeof(str), "%s \"%s\".\n",
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
path);
if (error_string)
free(error_string);
*error_string = strdup(str);
return false;
}
string_list_append(additional_path_allocs, new_path, attributes);
info[i].path =
additional_path_allocs->elems[additional_path_allocs->size -1 ].data;
if (!string_list_append(content_ctx->temporary_content, new_path, attributes))
return false;
return true;
}
void menu_shader_manager_save_preset(
const char *basename, bool apply)
{
char buffer[PATH_MAX], config_directory[PATH_MAX], cgp_path[PATH_MAX];
unsigned d, type = RARCH_SHADER_NONE;
config_file_t *conf = NULL;
bool ret = false;
if (!driver.menu)
{
RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n");
return;
}
type = menu_shader_manager_get_type(driver.menu->shader);
if (type == RARCH_SHADER_NONE)
return;
*config_directory = '\0';
if (basename)
{
strlcpy(buffer, basename, sizeof(buffer));
/* Append extension automatically as appropriate. */
if (!strstr(basename, ".cgp") && !strstr(basename, ".glslp"))
{
if (type == RARCH_SHADER_GLSL)
strlcat(buffer, ".glslp", sizeof(buffer));
else if (type == RARCH_SHADER_CG)
strlcat(buffer, ".cgp", sizeof(buffer));
}
}
else
{
const char *conf_path = (type == RARCH_SHADER_GLSL) ?
driver.menu->default_glslp : driver.menu->default_cgp;
strlcpy(buffer, conf_path, sizeof(buffer));
}
if (*g_extern.config_path)
fill_pathname_basedir(config_directory,
g_extern.config_path, sizeof(config_directory));
const char *dirs[] = {
g_settings.video.shader_dir,
g_settings.menu_config_directory,
config_directory,
};
if (!(conf = (config_file_t*)config_file_new(NULL)))
return;
gfx_shader_write_conf_cgp(conf, driver.menu->shader);
for (d = 0; d < ARRAY_SIZE(dirs); d++)
{
if (!*dirs[d])
continue;
fill_pathname_join(cgp_path, dirs[d], buffer, sizeof(cgp_path));
if (config_file_write(conf, cgp_path))
{
RARCH_LOG("Saved shader preset to %s.\n", cgp_path);
if (apply)
menu_shader_manager_set_preset(NULL, type, cgp_path);
ret = true;
break;
}
else
RARCH_LOG("Failed writing shader preset to %s.\n", cgp_path);
}
config_file_free(conf);
if (!ret)
RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n");
}
static bool load_content_need_fullpath(
struct retro_game_info *info, unsigned i,
struct string_list* additional_path_allocs,
bool need_fullpath, const char *path)
{
#ifdef HAVE_COMPRESSION
ssize_t len;
union string_list_elem_attr attributes;
char new_path[PATH_MAX_LENGTH] = {0};
char new_basedir[PATH_MAX_LENGTH] = {0};
bool ret = false;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *sys_info= rarch_system_info_get_ptr();
if (sys_info && sys_info->info.block_extract)
return true;
if (!need_fullpath)
return true;
if (!path_contains_compressed_file(path))
return true;
RARCH_LOG("Compressed file in case of need_fullpath."
"Now extracting to temporary directory.\n");
strlcpy(new_basedir, settings->extraction_directory,
sizeof(new_basedir));
if ((!strcmp(new_basedir, "")) ||
!path_is_directory(new_basedir))
{
RARCH_WARN("Tried extracting to extraction directory, but "
"extraction directory was not set or found. "
"Setting extraction directory to directory "
"derived by basename...\n");
fill_pathname_basedir(new_basedir, path,
sizeof(new_basedir));
}
attributes.i = 0;
fill_pathname_join(new_path, new_basedir,
path_basename(path), sizeof(new_path));
ret = read_compressed_file(path,NULL,new_path, &len);
if (!ret || len < 0)
{
RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
path);
return false;
}
string_list_append(additional_path_allocs,new_path, attributes);
info[i].path =
additional_path_allocs->elems
[additional_path_allocs->size -1 ].data;
/* global->temporary_content is initialized in init_content_file
* The following part takes care of cleanup of the unzipped files
* after exit.
*/
rarch_assert(global->temporary_content != NULL);
string_list_append(global->temporary_content,
new_path, attributes);
#endif
return true;
}
static void frontend_psp_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
struct rarch_main_wrap *params = NULL;
(void)args;
#ifndef IS_SALAMANDER
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
#ifndef VITA
retro_main_log_file_init("ms0:/temp/retroarch-log.txt");
#else
retro_main_log_file_init("ux0:/temp/retroarch-log.txt");
#endif
#endif
#endif
#ifdef VITA
strlcpy(eboot_path, "app0:/", sizeof(eboot_path));
strlcpy(g_defaults.dir.port, eboot_path, sizeof(g_defaults.dir.port));
strlcpy(user_path, "ux0:/data/retroarch/", sizeof(user_path));
#else
strlcpy(eboot_path, argv[0], sizeof(eboot_path));
/* for PSP, use uppercase directories, and no trailing slashes
otherwise mkdir fails */
strlcpy(user_path, "ms0:/PSP/RETROARCH", sizeof(user_path));
fill_pathname_basedir(g_defaults.dir.port, argv[0], sizeof(g_defaults.dir.port));
#endif
RARCH_LOG("port dir: [%s]\n", g_defaults.dir.port);
#ifdef VITA
/* bundle data*/
fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port,
"", sizeof(g_defaults.dir.core));
fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port,
"assets", sizeof(g_defaults.dir.assets));
fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.core,
"info", sizeof(g_defaults.dir.core_info));
fill_pathname_join(g_defaults.dir.database, g_defaults.dir.port,
"database/rdb", sizeof(g_defaults.dir.database));
fill_pathname_join(g_defaults.dir.cursor, g_defaults.dir.port,
"database/cursors", sizeof(g_defaults.dir.cursor));
/* user data*/
fill_pathname_join(g_defaults.dir.cheats, user_path,
"cheats", sizeof(g_defaults.dir.cheats));
fill_pathname_join(g_defaults.dir.menu_config, user_path,
"config", sizeof(g_defaults.dir.menu_config));
fill_pathname_join(g_defaults.dir.core_assets, user_path,
"downloads", sizeof(g_defaults.dir.core_assets));
fill_pathname_join(g_defaults.dir.playlist, user_path,
"playlists", sizeof(g_defaults.dir.playlist));
fill_pathname_join(g_defaults.dir.remap, user_path,
"remaps", sizeof(g_defaults.dir.remap));
fill_pathname_join(g_defaults.dir.sram, user_path,
"savefiles", sizeof(g_defaults.dir.sram));
fill_pathname_join(g_defaults.dir.savestate, user_path,
"savestates", sizeof(g_defaults.dir.savestate));
fill_pathname_join(g_defaults.dir.system, user_path,
"system", sizeof(g_defaults.dir.system));
fill_pathname_join(g_defaults.dir.cache, user_path,
"temp", sizeof(g_defaults.dir.cache));
fill_pathname_join(g_defaults.dir.overlay, user_path,
"overlays", sizeof(g_defaults.dir.overlay));
fill_pathname_join(g_defaults.dir.thumbnails, user_path,
"thumbnails", sizeof(g_defaults.dir.thumbnails));
strlcpy(g_defaults.dir.content_history,
user_path, sizeof(g_defaults.dir.content_history));
fill_pathname_join(g_defaults.path.config, user_path,
file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config));
#else
fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port,
"CORES", sizeof(g_defaults.dir.core));
fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.port,
"INFO", sizeof(g_defaults.dir.core_info));
/* bundle data */
/*
fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port,
"BUNDLE/ASSETS", sizeof(g_defaults.dir.assets));
fill_pathname_join(g_defaults.dir.autoconfig, g_defaults.dir.port,
"BUNDLE/AUTOCONFIG", sizeof(g_defaults.dir.autoconfig));
fill_pathname_join(g_defaults.dir.cursor, base_path,
"BUNDLE/DATABASE/CURSORS", sizeof(g_defaults.dir.cursor));
fill_pathname_join(g_defaults.dir.database, base_path,
"BUNDLE/DATABASE/RDB", sizeof(g_defaults.dir.database));
fill_pathname_join(g_defaults.dir.overlay, base_path,
"BUNDLE/OVERLAYS", sizeof(g_defaults.dir.overlay));
fill_pathname_join(g_defaults.dir.shader, base_path,
"BUNDLE/SHADERS", sizeof(g_defaults.dir.shader));
*/
/* user data */
fill_pathname_join(g_defaults.dir.cheats, user_path,
"CHEATS", sizeof(g_defaults.dir.cheats));
fill_pathname_join(g_defaults.dir.menu_config, user_path,
"CONFIG", sizeof(g_defaults.dir.menu_config));
fill_pathname_join(g_defaults.dir.core_assets, user_path,
"DOWNLOADS", sizeof(g_defaults.dir.core_assets));
fill_pathname_join(g_defaults.dir.playlist, user_path,
"PLAYLISTS", sizeof(g_defaults.dir.playlist));
fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.menu_config,
"REMAPS", sizeof(g_defaults.dir.remap));
fill_pathname_join(g_defaults.dir.sram, user_path,
"SAVEFILES", sizeof(g_defaults.dir.sram));
fill_pathname_join(g_defaults.dir.savestate, user_path,
"SAVESTATES", sizeof(g_defaults.dir.savestate));
fill_pathname_join(g_defaults.dir.screenshot, user_path,
"SCREENSHOTS", sizeof(g_defaults.dir.screenshot));
fill_pathname_join(g_defaults.dir.system, user_path,
"SYSTEM", sizeof(g_defaults.dir.system));
/* fill_pathname_join(g_defaults.dir.thumbnails, user_path,
"THUMBNAILS", sizeof(g_defaults.dir.thumbnails)); */
/* cache dir */
fill_pathname_join(g_defaults.dir.cache, user_path,
"TEMP", sizeof(g_defaults.dir.cache));
/* history and main config */
strlcpy(g_defaults.dir.content_history,
user_path, sizeof(g_defaults.dir.content_history));
fill_pathname_join(g_defaults.path.config, user_path,
file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config));
#endif
/* create user data dirs */
path_mkdir(g_defaults.dir.cheats);
path_mkdir(g_defaults.dir.core_assets);
path_mkdir(g_defaults.dir.playlist);
path_mkdir(g_defaults.dir.menu_config);
path_mkdir(g_defaults.dir.playlist);
path_mkdir(g_defaults.dir.remap);
path_mkdir(g_defaults.dir.savestate);
path_mkdir(g_defaults.dir.screenshot);
path_mkdir(g_defaults.dir.sram);
path_mkdir(g_defaults.dir.system);
#ifdef VITA
path_mkdir(g_defaults.dir.thumbnails);
#endif
/* create cache dir */
path_mkdir(g_defaults.dir.cache);
#ifndef IS_SALAMANDER
#ifdef VITA
params = (struct rarch_main_wrap*)params_data;
params->verbose = true;
#endif
if (!string_is_empty(argv[1]))
{
static char path[PATH_MAX_LENGTH] = {0};
struct rarch_main_wrap *args =
(struct rarch_main_wrap*)params_data;
if (args)
{
strlcpy(path, argv[1], sizeof(path));
args->touched = true;
args->no_content = false;
args->verbose = false;
args->config_path = NULL;
args->sram_path = NULL;
args->state_path = NULL;
args->content_path = path;
args->libretro_path = NULL;
RARCH_LOG("argv[0]: %s\n", argv[0]);
RARCH_LOG("argv[1]: %s\n", argv[1]);
RARCH_LOG("argv[2]: %s\n", argv[2]);
RARCH_LOG("Auto-start game %s.\n", argv[1]);
}
}
#endif
}
static bool load_content_from_compressed_archive(
struct string_list *temporary_content,
struct retro_game_info *info, unsigned i,
struct string_list* additional_path_allocs,
bool need_fullpath, const char *path)
{
union string_list_elem_attr attributes;
ssize_t new_path_len;
char new_path[PATH_MAX_LENGTH];
char new_basedir[PATH_MAX_LENGTH];
bool ret = false;
settings_t *settings = config_get_ptr();
rarch_system_info_t *sys_info= NULL;
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &sys_info);
if (sys_info && sys_info->info.block_extract)
return true;
if (!need_fullpath || !path_contains_compressed_file(path))
return true;
RARCH_LOG("Compressed file in case of need_fullpath."
" Now extracting to temporary directory.\n");
strlcpy(new_basedir, settings->cache_directory,
sizeof(new_basedir));
if (string_is_empty(new_basedir) || !path_is_directory(new_basedir))
{
RARCH_WARN("Tried extracting to cache directory, but "
"cache directory was not set or found. "
"Setting cache directory to directory "
"derived by basename...\n");
fill_pathname_basedir(new_basedir, path,
sizeof(new_basedir));
}
attributes.i = 0;
fill_pathname_join(new_path, new_basedir,
path_basename(path), sizeof(new_path));
ret = content_file_compressed_read(path, NULL, new_path, &new_path_len);
if (!ret || new_path_len < 0)
{
RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
path);
return false;
}
RARCH_LOG("New path is: [%s]\n", new_path);
string_list_append(additional_path_allocs, new_path, attributes);
info[i].path =
additional_path_allocs->elems[additional_path_allocs->size -1 ].data;
if (!string_list_append(temporary_content, new_path, attributes))
return false;
return true;
}
static void frontend_psp_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
struct rarch_main_wrap *params = NULL;
(void)args;
#ifndef IS_SALAMANDER
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
#ifndef VITA
retro_main_log_file_init("ms0:/retroarch-log.txt");
#endif
#endif
#endif
#ifdef VITA
strlcpy(eboot_path, "cache0:/retroarch/", sizeof(eboot_path));
strlcpy(g_defaults.dir.port, eboot_path, sizeof(g_defaults.dir.port));
#else
strlcpy(eboot_path, argv[0], sizeof(eboot_path));
fill_pathname_basedir(g_defaults.dir.port, argv[0], sizeof(g_defaults.dir.port));
#endif
RARCH_LOG("port dir: [%s]\n", g_defaults.dir.port);
fill_pathname_join(g_defaults.dir.core_assets, g_defaults.dir.port,
"downloads", sizeof(g_defaults.dir.core_assets));
fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port,
"media", sizeof(g_defaults.dir.assets));
fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port,
"cores", sizeof(g_defaults.dir.core));
fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.port,
"cores", sizeof(g_defaults.dir.core_info));
fill_pathname_join(g_defaults.dir.savestate, g_defaults.dir.core,
"savestates", sizeof(g_defaults.dir.savestate));
fill_pathname_join(g_defaults.dir.sram, g_defaults.dir.core,
"savefiles", sizeof(g_defaults.dir.sram));
fill_pathname_join(g_defaults.dir.system, g_defaults.dir.core,
"system", sizeof(g_defaults.dir.system));
fill_pathname_join(g_defaults.dir.playlist, g_defaults.dir.core,
"playlists", sizeof(g_defaults.dir.playlist));
fill_pathname_join(g_defaults.path.config, g_defaults.dir.port,
"retroarch.cfg", sizeof(g_defaults.path.config));
fill_pathname_join(g_defaults.dir.cheats, g_defaults.dir.port,
"cheats", sizeof(g_defaults.dir.cheats));
fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.port,
"remaps", sizeof(g_defaults.dir.remap));
#ifdef VITA
fill_pathname_join(g_defaults.dir.overlay, g_defaults.dir.core,
"overlays", sizeof(g_defaults.dir.overlay));
#endif
#ifdef VITA
params = (struct rarch_main_wrap*)params_data;
params->verbose = true;
#endif
#ifndef IS_SALAMANDER
if (!string_is_empty(argv[1]))
{
static char path[PATH_MAX_LENGTH];
struct rarch_main_wrap *args = NULL;
*path = '\0';
args = (struct rarch_main_wrap*)params_data;
if (args)
{
strlcpy(path, argv[1], sizeof(path));
args->touched = true;
args->no_content = false;
args->verbose = false;
args->config_path = NULL;
args->sram_path = NULL;
args->state_path = NULL;
args->content_path = path;
args->libretro_path = NULL;
RARCH_LOG("argv[0]: %s\n", argv[0]);
RARCH_LOG("argv[1]: %s\n", argv[1]);
RARCH_LOG("argv[2]: %s\n", argv[2]);
RARCH_LOG("Auto-start game %s.\n", argv[1]);
}
}
#endif
}
void fill_pathname_application_special(char *s,
size_t len, enum application_special_type type)
{
switch (type)
{
case APPLICATION_SPECIAL_DIRECTORY_AUTOCONFIG:
{
settings_t *settings = config_get_ptr();
fill_pathname_join(s,
settings->paths.directory_autoconfig,
settings->arrays.input_joypad_driver,
len);
}
break;
case APPLICATION_SPECIAL_DIRECTORY_CONFIG:
{
settings_t *settings = config_get_ptr();
/* Try config directory setting first,
* fallback to the location of the current configuration file. */
if (!string_is_empty(settings->paths.directory_menu_config))
strlcpy(s, settings->paths.directory_menu_config, len);
else if (!path_is_empty(RARCH_PATH_CONFIG))
fill_pathname_basedir(s, path_get(RARCH_PATH_CONFIG), len);
}
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_ZARCH_ICONS:
#ifdef HAVE_ZARCH
{
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_ZARCH_FONT:
#ifdef HAVE_ZARCH
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_ZARCH);
fill_pathname_join(s,
s1, "Roboto-Condensed.ttf", len);
free(s1);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_ZARCH:
#ifdef HAVE_ZARCH
{
settings_t *settings = config_get_ptr();
fill_pathname_join(s,
settings->paths.directory_assets,
"zarch",
len);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_ICONS:
#ifdef HAVE_XMB
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *s2 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = s2[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB);
fill_pathname_join(s2, s1, "png",
PATH_MAX_LENGTH * sizeof(char)
);
fill_pathname_slash(s2,
PATH_MAX_LENGTH * sizeof(char)
);
strlcpy(s, s2, len);
free(s1);
free(s2);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_BG:
#ifdef HAVE_XMB
{
settings_t *settings = config_get_ptr();
if (!string_is_empty(settings->paths.path_menu_wallpaper))
strlcpy(s, settings->paths.path_menu_wallpaper, len);
else
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_ICONS);
fill_pathname_join(s, s1,
file_path_str(FILE_PATH_BACKGROUND_IMAGE),
len);
free(s1);
}
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB:
#ifdef HAVE_XMB
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *s2 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
settings_t *settings = config_get_ptr();
s1[0] = s2[0] = '\0';
fill_pathname_join(
s1,
settings->paths.directory_assets,
"xmb",
PATH_MAX_LENGTH * sizeof(char)
);
fill_pathname_join(s2,
s1, xmb_theme_ident(),
PATH_MAX_LENGTH * sizeof(char)
);
strlcpy(s, s2, len);
free(s1);
free(s2);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_MATERIALUI:
#ifdef HAVE_MATERIALUI
{
settings_t *settings = config_get_ptr();
fill_pathname_join(
s,
settings->paths.directory_assets,
"glui",
len);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_MATERIALUI_ICONS:
#ifdef HAVE_MATERIALUI
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_MATERIALUI);
fill_pathname_slash(s1,
PATH_MAX_LENGTH * sizeof(char)
);
strlcpy(s, s1, len);
free(s1);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_MATERIALUI_FONT:
#ifdef HAVE_MATERIALUI
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_MATERIALUI);
fill_pathname_join(s, s1, "font.ttf", len);
free(s1);
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_FONT:
#ifdef HAVE_XMB
{
settings_t *settings = config_get_ptr();
if (!string_is_empty(settings->paths.path_menu_xmb_font))
strlcpy(s, settings->paths.path_menu_xmb_font, len);
else
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
s1[0] = '\0';
fill_pathname_application_special(s1,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB);
fill_pathname_join(s, s1,
file_path_str(FILE_PATH_TTF_FONT),
len);
free(s1);
}
}
#endif
break;
case APPLICATION_SPECIAL_DIRECTORY_THUMBNAILS_CHEEVOS_BADGES:
{
char *s1 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *s2 = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
settings_t *settings = config_get_ptr();
s1[0] = s2[0] = '\0';
fill_pathname_join(s1,
settings->paths.directory_thumbnails,
"cheevos",
len);
fill_pathname_join(s2,
s1, "badges",
PATH_MAX_LENGTH * sizeof(char)
);
fill_pathname_slash(s2,
PATH_MAX_LENGTH * sizeof(char)
);
strlcpy(s, s2, len);
free(s1);
free(s2);
}
break;
case APPLICATION_SPECIAL_NONE:
default:
break;
}
}
/**
* menu_shader_manager_save_preset:
* @basename : basename of preset
* @apply : immediately set preset after saving
*
* Save a shader preset to disk.
**/
void menu_shader_manager_save_preset(
const char *basename, bool apply)
{
#ifdef HAVE_SHADER_MANAGER
char buffer[PATH_MAX_LENGTH], config_directory[PATH_MAX_LENGTH], preset_path[PATH_MAX_LENGTH];
unsigned d, type = RARCH_SHADER_NONE;
const char *dirs[3] = {0};
config_file_t *conf = NULL;
bool ret = false;
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
{
RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n");
return;
}
type = menu_shader_manager_get_type(menu->shader);
if (type == RARCH_SHADER_NONE)
return;
*config_directory = '\0';
if (basename)
{
strlcpy(buffer, basename, sizeof(buffer));
/* Append extension automatically as appropriate. */
if (!strstr(basename, ".cgp") && !strstr(basename, ".glslp"))
{
switch (type)
{
case RARCH_SHADER_GLSL:
strlcat(buffer, ".glslp", sizeof(buffer));
break;
case RARCH_SHADER_CG:
strlcat(buffer, ".cgp", sizeof(buffer));
break;
}
}
}
else
{
const char *conf_path = (type == RARCH_SHADER_GLSL) ?
menu->default_glslp : menu->default_cgp;
strlcpy(buffer, conf_path, sizeof(buffer));
}
if (*global->path.config)
fill_pathname_basedir(config_directory,
global->path.config, sizeof(config_directory));
dirs[0] = settings->video.shader_dir;
dirs[1] = settings->menu_config_directory;
dirs[2] = config_directory;
if (!(conf = (config_file_t*)config_file_new(NULL)))
return;
video_shader_write_conf_cgp(conf, menu->shader);
for (d = 0; d < ARRAY_SIZE(dirs); d++)
{
if (!*dirs[d])
continue;
fill_pathname_join(preset_path, dirs[d], buffer, sizeof(preset_path));
if (config_file_write(conf, preset_path))
{
RARCH_LOG("Saved shader preset to %s.\n", preset_path);
if (apply)
menu_shader_manager_set_preset(NULL, type, preset_path);
ret = true;
break;
}
else
RARCH_LOG("Failed writing shader preset to %s.\n", preset_path);
}
config_file_free(conf);
if (!ret)
RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n");
#endif
}
