static bool cmd_set_shader(const char *arg)
{
char msg[PATH_MAX_LENGTH] = {0};
enum rarch_shader_type type = RARCH_SHADER_NONE;
const char *ext = path_get_extension(arg);
uint32_t ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case COMMAND_EXT_GLSL:
case COMMAND_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case COMMAND_EXT_CG:
case COMMAND_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return false;
}
snprintf(msg, sizeof(msg), "Shader: \"%s\"", arg);
rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
arg);
return video_driver_set_shader(type, arg);
}
/**
* find_driver_nonempty:
* @label : string of driver type to be found.
* @i : index of driver.
* @str : identifier name of the found driver
* gets written to this string.
* @len : size of @str.
*
* Find driver based on @label.
*
* Returns: NULL if no driver based on @label found, otherwise
* pointer to driver.
**/
static const void *find_driver_nonempty(const char *label, int i,
char *s, size_t len)
{
const void *drv = NULL;
uint32_t hash = msg_hash_calculate(label);
switch (hash)
{
case HASH_CAMERA_DRIVER:
drv = camera_driver_find_handle(i);
if (drv)
strlcpy(s, camera_driver_find_ident(i), len);
break;
case HASH_LOCATION_DRIVER:
drv = location_driver_find_handle(i);
if (drv)
strlcpy(s, location_driver_find_ident(i), len);
break;
case HASH_MENU_DRIVER:
#ifdef HAVE_MENU
drv = menu_driver_find_handle(i);
if (drv)
strlcpy(s, menu_driver_find_ident(i), len);
#endif
break;
case HASH_INPUT_DRIVER:
drv = input_driver_find_handle(i);
if (drv)
strlcpy(s, input_driver_find_ident(i), len);
break;
case HASH_INPUT_JOYPAD_DRIVER:
drv = joypad_driver_find_handle(i);
if (drv)
strlcpy(s, joypad_driver_find_ident(i), len);
break;
case HASH_VIDEO_DRIVER:
drv = video_driver_find_handle(i);
if (drv)
strlcpy(s, video_driver_find_ident(i), len);
break;
case HASH_AUDIO_DRIVER:
drv = audio_driver_find_handle(i);
if (drv)
strlcpy(s, audio_driver_find_ident(i), len);
break;
case HASH_RECORD_DRIVER:
drv = record_driver_find_handle(i);
if (drv)
strlcpy(s, record_driver_find_ident(i), len);
break;
case HASH_AUDIO_RESAMPLER_DRIVER:
drv = audio_resampler_driver_find_handle(i);
if (drv)
strlcpy(s, audio_resampler_driver_find_ident(i), len);
break;
}
return drv;
}
enum rarch_content_type path_is_media_type(const char *path)
{
char ext_lower[128];
ext_lower[0] = '\0';
strlcpy(ext_lower, path_get_extension(path), sizeof(ext_lower));
string_to_lower(ext_lower);
switch (msg_hash_to_file_type(msg_hash_calculate(ext_lower)))
{
#ifdef HAVE_FFMPEG
case FILE_TYPE_OGM:
case FILE_TYPE_MKV:
case FILE_TYPE_AVI:
case FILE_TYPE_MP4:
case FILE_TYPE_FLV:
case FILE_TYPE_WEBM:
case FILE_TYPE_3GP:
case FILE_TYPE_3G2:
case FILE_TYPE_F4F:
case FILE_TYPE_F4V:
case FILE_TYPE_MOV:
case FILE_TYPE_WMV:
case FILE_TYPE_MPG:
case FILE_TYPE_MPEG:
case FILE_TYPE_VOB:
case FILE_TYPE_ASF:
case FILE_TYPE_DIVX:
case FILE_TYPE_M2P:
case FILE_TYPE_M2TS:
case FILE_TYPE_PS:
case FILE_TYPE_TS:
case FILE_TYPE_MXF:
return RARCH_CONTENT_MOVIE;
case FILE_TYPE_WMA:
case FILE_TYPE_OGG:
case FILE_TYPE_MP3:
case FILE_TYPE_M4A:
case FILE_TYPE_FLAC:
case FILE_TYPE_WAV:
return RARCH_CONTENT_MUSIC;
#endif
#ifdef HAVE_IMAGEVIEWER
case FILE_TYPE_JPEG:
case FILE_TYPE_PNG:
case FILE_TYPE_TGA:
case FILE_TYPE_BMP:
return RARCH_CONTENT_IMAGE;
#endif
case FILE_TYPE_NONE:
default:
break;
}
return RARCH_CONTENT_NONE;
}
/**
* check_shader_dir:
* @pressed_next : was next shader key pressed?
* @pressed_previous : was previous shader key pressed?
*
* Checks if any one of the shader keys has been pressed for this frame:
* a) Next shader index.
* b) Previous shader index.
*
* Will also immediately apply the shader.
**/
static void check_shader_dir(rarch_dir_list_t *dir_list,
bool pressed_next, bool pressed_prev)
{
uint32_t ext_hash;
char msg[128];
const char *shader = NULL;
const char *ext = NULL;
enum rarch_shader_type type = RARCH_SHADER_NONE;
if (!dir_list || !dir_list->list)
return;
if (pressed_next)
{
dir_list->ptr = (dir_list->ptr + 1) %
dir_list->list->size;
}
else if (pressed_prev)
{
if (dir_list->ptr == 0)
dir_list->ptr = dir_list->list->size - 1;
else
dir_list->ptr--;
}
else
return;
shader = dir_list->list->elems[dir_list->ptr].data;
ext = path_get_extension(shader);
ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case SHADER_EXT_GLSL:
case SHADER_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case SHADER_EXT_CG:
case SHADER_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return;
}
snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)dir_list->ptr, shader);
runloop_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader))
RARCH_WARN("%s\n", msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
}
/**
* check_shader_dir:
* @pressed_next : was next shader key pressed?
* @pressed_previous : was previous shader key pressed?
*
* Checks if any one of the shader keys has been pressed for this frame:
* a) Next shader index.
* b) Previous shader index.
*
* Will also immediately apply the shader.
**/
static void check_shader_dir(global_t *global,
bool pressed_next, bool pressed_prev)
{
uint32_t ext_hash;
char msg[PATH_MAX_LENGTH] = {0};
const char *shader = NULL;
const char *ext = NULL;
enum rarch_shader_type type = RARCH_SHADER_NONE;
if (!global || !global->shader_dir.list)
return;
if (pressed_next)
{
global->shader_dir.ptr = (global->shader_dir.ptr + 1) %
global->shader_dir.list->size;
}
else if (pressed_prev)
{
if (global->shader_dir.ptr == 0)
global->shader_dir.ptr = global->shader_dir.list->size - 1;
else
global->shader_dir.ptr--;
}
else
return;
shader = global->shader_dir.list->elems[global->shader_dir.ptr].data;
ext = path_get_extension(shader);
ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case SHADER_EXT_GLSL:
case SHADER_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case SHADER_EXT_CG:
case SHADER_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return;
}
snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)global->shader_dir.ptr, shader);
rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader))
RARCH_WARN(msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
}
static int task_database_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(name))))
{
case FILE_TYPE_COMPRESSED:
#ifdef HAVE_COMPRESSION
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
/* first check crc of archive itself */
return file_get_crc(db_state, name, &db_state->archive_crc);
#else
break;
#endif
case FILE_TYPE_CUE:
db_state->serial[0] = '\0';
if (cue_get_serial(db_state, db, name, db_state->serial))
{
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
}
else
{
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return file_get_crc(db_state, name, &db_state->crc);
}
break;
case FILE_TYPE_ISO:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
break;
case FILE_TYPE_CHD:
db_state->serial[0] = '\0';
if (chd_get_serial(db_state, db, name, db_state->serial))
{
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
}
else
{
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return chd_get_crc(db_state, name, &db_state->crc);
}
break;
case FILE_TYPE_LUTRO:
database_info_set_type(db, DATABASE_TYPE_ITERATE_LUTRO);
break;
default:
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return file_get_crc(db_state, name, &db_state->crc);
}
return 1;
}
static int database_info_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
uint32_t extension_hash = 0;
char parent_dir[PATH_MAX_LENGTH] = {0};
path_parent_dir(parent_dir);
extension_hash = msg_hash_calculate(path_get_extension(name));
switch (extension_hash)
{
case HASH_EXTENSION_ZIP:
#ifdef HAVE_ZLIB
db->type = DATABASE_TYPE_ITERATE_ZIP;
memset(&db->state, 0, sizeof(zlib_transfer_t));
db_state->zip_name[0] = '\0';
db->state.type = ZLIB_TRANSFER_INIT;
return 1;
#endif
case HASH_EXTENSION_CUE:
case HASH_EXTENSION_CUE_UPPERCASE:
db_state->serial[0] = '\0';
cue_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
case HASH_EXTENSION_ISO:
case HASH_EXTENSION_ISO_UPPERCASE:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
default:
{
ssize_t ret;
int read_from = read_file(name, (void**)&db_state->buf, &ret);
if (read_from != 1 || ret <= 0)
return 0;
#ifdef HAVE_ZLIB
db_state->crc = zlib_crc32_calculate(db_state->buf, ret);
#endif
db->type = DATABASE_TYPE_CRC_LOOKUP;
}
break;
}
return 1;
}
/**
* rarch_defer_core:
* @core_info : Core info list handle.
* @dir : Directory. Gets joined with @path.
* @path : Path. Gets joined with @dir.
* @menu_label : Label identifier of menu setting.
* @s : Deferred core path. Will be filled in
* by function.
* @len : Size of @s.
*
* Gets deferred core.
*
* Returns: 0 if there are multiple deferred cores and a
* selection needs to be made from a list, otherwise
* returns -1 and fills in @s with path to core.
**/
int rarch_defer_core(core_info_list_t *core_info, const char *dir,
const char *path, const char *menu_label,
char *s, size_t len)
{
char new_core_path[PATH_MAX_LENGTH] = {0};
const core_info_t *info = NULL;
size_t supported = 0;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
uint32_t menu_label_hash = msg_hash_calculate(menu_label);
fill_pathname_join(s, dir, path, len);
#ifdef HAVE_COMPRESSION
if (path_is_compressed_file(dir))
{
/* In case of a compressed archive, we have to join with a hash */
/* We are going to write at the position of dir: */
rarch_assert(strlen(dir) < strlen(s));
s[strlen(dir)] = '#';
}
#endif
if (core_info)
core_info_list_get_supported_cores(core_info, s, &info,
&supported);
if (menu_label_hash == MENU_LABEL_LOAD_CONTENT)
{
info = (const core_info_t*)&global->core_info.current;
if (info)
{
strlcpy(new_core_path, info->path, sizeof(new_core_path));
supported = 1;
}
}
else
strlcpy(new_core_path, info->path, sizeof(new_core_path));
/* There are multiple deferred cores and a
* selection needs to be made from a list, return 0. */
if (supported != 1)
return 0;
strlcpy(global->path.fullpath, s, sizeof(global->path.fullpath));
if (path_file_exists(new_core_path))
strlcpy(settings->libretro, new_core_path,
sizeof(settings->libretro));
return -1;
}
enum rarch_content_type rarch_path_is_media_type(const char *path)
{
uint32_t hash_ext = msg_hash_calculate(path_get_extension(path));
switch (hash_ext)
{
#ifdef HAVE_FFMPEG
case MENU_VALUE_FILE_OGM:
case MENU_VALUE_FILE_MKV:
case MENU_VALUE_FILE_AVI:
case MENU_VALUE_FILE_MP4:
case MENU_VALUE_FILE_FLV:
case MENU_VALUE_FILE_WEBM:
case MENU_VALUE_FILE_3GP:
case MENU_VALUE_FILE_F4F:
case MENU_VALUE_FILE_F4V:
case MENU_VALUE_FILE_MOV:
case MENU_VALUE_FILE_WMV:
return RARCH_CONTENT_MOVIE;
case MENU_VALUE_FILE_MP3:
case MENU_VALUE_FILE_M4A:
case MENU_VALUE_FILE_OGG:
case MENU_VALUE_FILE_FLAC:
case MENU_VALUE_FILE_WAV:
return RARCH_CONTENT_MUSIC;
#endif
#ifdef HAVE_IMAGEVIEWER
case MENU_VALUE_FILE_JPG:
case MENU_VALUE_FILE_JPG_CAPS:
case MENU_VALUE_FILE_JPEG:
case MENU_VALUE_FILE_JPEG_CAPS:
case MENU_VALUE_FILE_PNG:
case MENU_VALUE_FILE_PNG_CAPS:
case MENU_VALUE_FILE_TGA:
case MENU_VALUE_FILE_BMP:
return RARCH_CONTENT_IMAGE;
#endif
case 0:
default:
break;
}
return RARCH_CONTENT_NONE;
}
static int task_database_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
uint32_t extension_hash = 0;
char parent_dir[PATH_MAX_LENGTH] = {0};
path_parent_dir(parent_dir);
extension_hash = msg_hash_calculate(path_get_extension(name));
switch (extension_hash)
{
case HASH_EXTENSION_ZIP:
#ifdef HAVE_ZLIB
db->type = DATABASE_TYPE_ITERATE_ZIP;
memset(&db->state, 0, sizeof(file_archive_transfer_t));
db_state->zip_name[0] = '\0';
db->state.type = ZLIB_TRANSFER_INIT;
return file_get_crc(db_state, name, &db_state->zip_crc);
#endif
case HASH_EXTENSION_CUE:
case HASH_EXTENSION_CUE_UPPERCASE:
db_state->serial[0] = '\0';
cue_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
case HASH_EXTENSION_ISO:
case HASH_EXTENSION_ISO_UPPERCASE:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
default:
{
db->type = DATABASE_TYPE_CRC_LOOKUP;
return file_get_crc(db_state, name, &db_state->crc);
}
break;
}
return 1;
}
static int database_info_poll(db_handle_t *db)
{
char elem0[PATH_MAX_LENGTH];
uint32_t cb_type_hash = 0;
struct string_list *str_list = NULL;
const char *path = msg_queue_pull(db->msg_queue);
if (!path)
return -1;
str_list = string_split(path, "|");
if (!str_list)
goto error;
if (str_list->size < 1)
goto error;
strlcpy(elem0, str_list->elems[0].data, sizeof(elem0));
if (str_list->size > 1)
cb_type_hash = msg_hash_calculate(str_list->elems[1].data);
switch (cb_type_hash)
{
case CB_DB_SCAN_FILE:
db->handle = database_info_file_init(elem0, DATABASE_TYPE_ITERATE);
break;
case CB_DB_SCAN_FOLDER:
db->handle = database_info_dir_init(elem0, DATABASE_TYPE_ITERATE);
break;
}
string_list_free(str_list);
return 0;
error:
if (str_list)
string_list_free(str_list);
return -1;
}
static int task_database_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
char parent_dir[PATH_MAX_LENGTH] = {0};
path_parent_dir(parent_dir);
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(name))))
{
case FILE_TYPE_COMPRESSED:
#ifdef HAVE_ZLIB
db->type = DATABASE_TYPE_ITERATE_ZIP;
memset(&db->state, 0, sizeof(file_archive_transfer_t));
db_state->zip_name[0] = '\0';
db->state.type = ZLIB_TRANSFER_INIT;
return file_get_crc(db_state, name, &db_state->zip_crc);
#else
break;
#endif
case FILE_TYPE_CUE:
db_state->serial[0] = '\0';
cue_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
break;
case FILE_TYPE_ISO:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
break;
case FILE_TYPE_LUTRO:
db->type = DATABASE_TYPE_ITERATE_LUTRO;
break;
default:
db->type = DATABASE_TYPE_CRC_LOOKUP;
return file_get_crc(db_state, name, &db_state->crc);
}
return 1;
}
static enum frontend_architecture frontend_android_get_architecture(void)
{
uint32_t abi_hash;
char abi[PROP_VALUE_MAX] = {0};
system_property_get("ro.product.cpu.abi", abi);
abi_hash = msg_hash_calculate(abi);
switch (abi_hash)
{
case ANDROID_ARCH_ARMV7:
return FRONTEND_ARCH_ARM;
case ANDROID_ARCH_ARM:
return FRONTEND_ARCH_ARM;
case ANDROID_ARCH_MIPS:
return FRONTEND_ARCH_MIPS;
case ANDROID_ARCH_X86:
return FRONTEND_ARCH_X86;
}
return FRONTEND_ARCH_NONE;
}
/**
* video_shader_parse_type:
* @path : Shader path.
* @fallback : Fallback shader type in case no
* type could be found.
*
* Parses type of shader.
*
* Returns: value of shader type on success, otherwise will return
* user-supplied @fallback value.
**/
enum rarch_shader_type video_shader_parse_type(const char *path,
enum rarch_shader_type fallback)
{
if (!path)
return fallback;
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(path))))
{
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_PRESET_CGP:
return RARCH_SHADER_CG;
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_PRESET_GLSLP:
return RARCH_SHADER_GLSL;
case FILE_TYPE_SHADER_SLANG:
case FILE_TYPE_SHADER_PRESET_SLANGP:
return RARCH_SHADER_SLANG;
default:
break;
}
return fallback;
}
/**
* menu_shader_manager_init:
*
* Initializes shader manager.
**/
void menu_shader_manager_init(void)
{
#ifdef HAVE_SHADER_MANAGER
struct video_shader *shader = NULL;
config_file_t *conf = NULL;
settings_t *settings = config_get_ptr();
const char *config_path = path_get(RARCH_PATH_CONFIG);
menu_driver_ctl(RARCH_MENU_CTL_SHADER_GET,
&shader);
/* In a multi-config setting, we can't have
* conflicts on menu.cgp/menu.glslp. */
if (config_path)
{
fill_pathname_base_ext(default_glslp, config_path,
file_path_str(FILE_PATH_GLSLP_EXTENSION),
sizeof(default_glslp));
fill_pathname_base_ext(default_cgp, config_path,
file_path_str(FILE_PATH_CGP_EXTENSION),
sizeof(default_cgp));
fill_pathname_base_ext(default_slangp, config_path,
file_path_str(FILE_PATH_SLANGP_EXTENSION),
sizeof(default_slangp));
}
else
{
strlcpy(default_glslp, "menu.glslp",
sizeof(default_glslp));
strlcpy(default_cgp, "menu.cgp",
sizeof(default_cgp));
strlcpy(default_slangp, "menu.slangp",
sizeof(default_slangp));
}
switch (msg_hash_to_file_type(msg_hash_calculate(
path_get_extension(settings->path.shader))))
{
case FILE_TYPE_SHADER_PRESET_GLSLP:
case FILE_TYPE_SHADER_PRESET_CGP:
case FILE_TYPE_SHADER_PRESET_SLANGP:
conf = config_file_new(settings->path.shader);
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader,
settings->path.shader);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
break;
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_SLANG:
strlcpy(shader->pass[0].source.path, settings->path.shader,
sizeof(shader->pass[0].source.path));
shader->passes = 1;
break;
default:
{
char preset_path[PATH_MAX_LENGTH];
const char *shader_dir =
*settings->directory.video_shader ?
settings->directory.video_shader : settings->directory.system;
preset_path[0] = '\0';
fill_pathname_join(preset_path, shader_dir,
"menu.glslp", sizeof(preset_path));
conf = config_file_new(preset_path);
if (!conf)
{
fill_pathname_join(preset_path, shader_dir,
"menu.cgp", sizeof(preset_path));
conf = config_file_new(preset_path);
}
if (!conf)
{
fill_pathname_join(preset_path, shader_dir,
"menu.slangp", sizeof(preset_path));
conf = config_file_new(preset_path);
}
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader, preset_path);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
}
break;
}
#endif
}
void path_set_redirect(void)
{
char new_savefile_dir[PATH_MAX_LENGTH];
char new_savestate_dir[PATH_MAX_LENGTH];
uint32_t library_name_hash = 0;
bool check_library_name_hash = false;
rarch_system_info_t *info = NULL;
global_t *global = global_get_ptr();
const char *old_savefile_dir = dir_get(RARCH_DIR_SAVEFILE);
const char *old_savestate_dir = dir_get(RARCH_DIR_SAVESTATE);
new_savefile_dir[0] = new_savestate_dir[0] = '\0';
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &info);
if (info && info->info.library_name &&
!string_is_empty(info->info.library_name))
library_name_hash =
msg_hash_calculate(info->info.library_name);
/* Initialize current save directories
* with the values from the config. */
strlcpy(new_savefile_dir,
old_savefile_dir,
sizeof(new_savefile_dir));
strlcpy(new_savestate_dir,
old_savestate_dir,
sizeof(new_savestate_dir));
check_library_name_hash = (library_name_hash != 0);
#ifdef HAVE_MENU
check_library_name_hash = check_library_name_hash &&
(library_name_hash != MENU_VALUE_NO_CORE);
#endif
if (check_library_name_hash)
{
settings_t *settings = config_get_ptr();
/* per-core saves: append the library_name to the save location */
if ( settings->sort_savefiles_enable
&& !string_is_empty(old_savefile_dir))
{
fill_pathname_join(
new_savefile_dir,
old_savefile_dir,
info->info.library_name,
sizeof(new_savefile_dir));
/* If path doesn't exist, try to create it,
* if everything fails revert to the original path. */
if(!path_is_directory(new_savefile_dir)
&& !string_is_empty(new_savefile_dir))
{
path_mkdir(new_savefile_dir);
if(!path_is_directory(new_savefile_dir))
{
RARCH_LOG("%s %s\n",
msg_hash_to_str(MSG_REVERTING_SAVEFILE_DIRECTORY_TO),
old_savefile_dir);
strlcpy(new_savefile_dir,
old_savefile_dir,
sizeof(new_savefile_dir));
}
}
}
/* per-core states: append the library_name to the save location */
if (settings->sort_savestates_enable
&& !string_is_empty(old_savestate_dir))
{
fill_pathname_join(
new_savestate_dir,
old_savestate_dir,
info->info.library_name,
sizeof(new_savestate_dir));
/* If path doesn't exist, try to create it.
* If everything fails, revert to the original path. */
if(!path_is_directory(new_savestate_dir) &&
!string_is_empty(new_savestate_dir))
{
path_mkdir(new_savestate_dir);
if(!path_is_directory(new_savestate_dir))
{
RARCH_LOG("%s %s\n",
msg_hash_to_str(MSG_REVERTING_SAVESTATE_DIRECTORY_TO),
old_savestate_dir);
strlcpy(new_savestate_dir,
old_savestate_dir,
sizeof(new_savestate_dir));
}
}
}
}
/* Set savefile directory if empty based on content directory */
if (string_is_empty(new_savefile_dir))
{
strlcpy(new_savefile_dir, path_main_basename,
sizeof(new_savefile_dir));
path_basedir(new_savefile_dir);
}
if (global)
{
if(path_is_directory(new_savefile_dir))
strlcpy(global->name.savefile, new_savefile_dir,
sizeof(global->name.savefile));
if(path_is_directory(new_savestate_dir))
strlcpy(global->name.savestate, new_savestate_dir,
sizeof(global->name.savestate));
if (path_is_directory(global->name.savefile))
{
fill_pathname_dir(global->name.savefile, path_main_basename,
file_path_str(FILE_PATH_SRM_EXTENSION),
sizeof(global->name.savefile));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVEFILE_TO),
global->name.savefile);
}
if (path_is_directory(global->name.savestate))
{
fill_pathname_dir(global->name.savestate, path_main_basename,
file_path_str(FILE_PATH_STATE_EXTENSION),
sizeof(global->name.savestate));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO),
global->name.savestate);
}
if (path_is_directory(global->name.cheatfile))
{
fill_pathname_dir(global->name.cheatfile, path_main_basename,
file_path_str(FILE_PATH_STATE_EXTENSION),
sizeof(global->name.cheatfile));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_CHEATFILE_TO),
global->name.cheatfile);
}
}
dir_set(RARCH_DIR_CURRENT_SAVEFILE, new_savefile_dir);
dir_set(RARCH_DIR_CURRENT_SAVESTATE, new_savestate_dir);
}
/**
* runloop_check_shader_dir:
* @pressed_next : was next shader key pressed?
* @pressed_previous : was previous shader key pressed?
*
* Checks if any one of the shader keys has been pressed for this frame:
* a) Next shader index.
* b) Previous shader index.
*
* Will also immediately apply the shader.
**/
static void runloop_check_shader_dir(rarch_dir_list_t *dir_list,
bool pressed_next, bool pressed_prev)
{
char msg[128] = {0};
const char *shader = NULL;
enum rarch_shader_type type = RARCH_SHADER_NONE;
RARCH_LOG("SWITCH \n");
if (!dir_list || !dir_list->list)
return;
if (pressed_next)
{
dir_list->ptr = (dir_list->ptr + 1) %
dir_list->list->size;
}
else if (pressed_prev)
{
if (dir_list->ptr == 0)
dir_list->ptr = dir_list->list->size - 1;
else
dir_list->ptr--;
}
else
return;
shader = dir_list->list->elems[dir_list->ptr].data;
RARCH_LOG("SWITCH %s,\n", shader);
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(shader))))
{
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_PRESET_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case FILE_TYPE_SHADER_SLANG:
case FILE_TYPE_SHADER_PRESET_SLANGP:
type = RARCH_SHADER_SLANG;
break;
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_PRESET_CGP:
type = RARCH_SHADER_CG;
break;
default:
return;
}
snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)dir_list->ptr, shader);
runloop_msg_queue_push(msg, 2, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader))
RARCH_WARN("%s\n", msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
}
/**
* menu_iterate:
* @input : input sample for this frame
* @old_input : input sample of the previous frame
* @trigger_input : difference' input sample - difference
* between 'input' and 'old_input'
*
* Runs RetroArch menu for one frame.
*
* Returns: 0 on success, -1 if we need to quit out of the loop.
**/
int generic_menu_iterate(void *data, void *userdata, enum menu_action action)
{
menu_entry_t entry;
enum action_iterate_type iterate_type;
size_t selection = 0;
unsigned file_type = 0;
int ret = 0;
uint32_t hash = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
const char *label = NULL;
menu_handle_t *menu = (menu_handle_t*)data;
menu_entries_get_last_stack(NULL, &label, &file_type, &enum_idx, NULL);
if (!menu)
return 0;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return 0;
menu->menu_state.msg[0] = '\0';
hash = msg_hash_calculate(label);
iterate_type = action_iterate_type(hash);
menu_driver_set_binding_state(iterate_type == ITERATE_TYPE_BIND);
if ( action != MENU_ACTION_NOOP
|| menu_entries_ctl(MENU_ENTRIES_CTL_NEEDS_REFRESH, NULL)
|| menu_display_get_update_pending())
{
BIT64_SET(menu->state, MENU_STATE_RENDER_FRAMEBUFFER);
}
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = menu_dialog_iterate(
menu->menu_state.msg, sizeof(menu->menu_state.msg), label);
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (ret == 1 || action == MENU_ACTION_OK)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
menu_dialog_set_active(false);
}
if (action == MENU_ACTION_CANCEL)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
menu_dialog_set_active(false);
}
break;
case ITERATE_TYPE_BIND:
{
menu_input_ctx_bind_t bind;
bind.s = menu->menu_state.msg;
bind.len = sizeof(menu->menu_state.msg);
if (menu_input_key_bind_iterate(&bind))
{
menu_entries_pop_stack(&selection, 0, 0);
menu_navigation_ctl(
MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
else
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
}
break;
case ITERATE_TYPE_INFO:
{
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
menu_file_list_cbs_t *cbs =
menu_entries_get_actiondata_at_offset(selection_buf, selection);
if (cbs->enum_idx != MSG_UNKNOWN)
{
ret = menu_hash_get_help_enum(cbs->enum_idx,
menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
else
{
unsigned type = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
menu_entries_get_at_offset(selection_buf, selection,
NULL, NULL, &type, NULL, NULL);
switch (type)
{
case FILE_TYPE_FONT:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_FONT;
break;
case FILE_TYPE_RDB:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_RDB;
break;
case FILE_TYPE_OVERLAY:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_OVERLAY;
break;
case FILE_TYPE_CHEAT:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CHEAT;
break;
case FILE_TYPE_SHADER_PRESET:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_SHADER_PRESET;
break;
case FILE_TYPE_SHADER:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_SHADER;
break;
case FILE_TYPE_REMAP:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_REMAP;
break;
case FILE_TYPE_RECORD_CONFIG:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_RECORD_CONFIG;
break;
case FILE_TYPE_CURSOR:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CURSOR;
break;
case FILE_TYPE_CONFIG:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CONFIG;
break;
case FILE_TYPE_CARCHIVE:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_COMPRESSED_ARCHIVE;
break;
case FILE_TYPE_DIRECTORY:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_DIRECTORY;
break;
case FILE_TYPE_VIDEOFILTER: /* TODO/FIXME */
case FILE_TYPE_AUDIOFILTER: /* TODO/FIXME */
case FILE_TYPE_SHADER_SLANG: /* TODO/FIXME */
case FILE_TYPE_SHADER_GLSL: /* TODO/FIXME */
case FILE_TYPE_SHADER_HLSL: /* TODO/FIXME */
case FILE_TYPE_SHADER_CG: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_GLSLP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_HLSLP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_CGP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_SLANGP: /* TODO/FIXME */
case FILE_TYPE_PLAIN:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_PLAIN_FILE;
break;
default:
break;
}
if (enum_idx != MSG_UNKNOWN)
ret = menu_hash_get_help_enum(enum_idx,
menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
}
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (action == MENU_ACTION_OK || action == MENU_ACTION_CANCEL)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
}
menu_dialog_set_active(false);
break;
case ITERATE_TYPE_DEFAULT:
/* FIXME: Crappy hack, needed for mouse controls
* to not be completely broken in case we press back.
*
* We need to fix this entire mess, mouse controls
* should not rely on a hack like this in order to work. */
selection = MAX(MIN(selection, (menu_entries_get_size() - 1)), 0);
menu_entry_get(&entry, 0, selection, NULL, false);
ret = menu_entry_action(&entry, selection, (enum menu_action)action);
if (ret)
goto end;
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
/* Have to defer it so we let settings refresh. */
menu_dialog_push();
break;
}
BIT64_SET(menu->state, MENU_STATE_BLIT);
if (BIT64_GET(menu->state, MENU_STATE_POP_STACK))
{
size_t new_selection_ptr = selection;
menu_entries_pop_stack(&new_selection_ptr, 0, 0);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
if (BIT64_GET(menu->state, MENU_STATE_POST_ITERATE))
menu_input_post_iterate(&ret, action);
end:
if (ret)
return -1;
return 0;
}
/* This sets up all the callback functions for a menu entry.
*
* OK : When we press the 'OK' button on an entry.
* Cancel : When we press the 'Cancel' button on an entry.
* Scan : When we press the 'Scan' button on an entry.
* Start : When we press the 'Start' button on an entry.
* Select : When we press the 'Select' button on an entry.
* Info : When we press the 'Info' button on an entry.
* Content Switch : ??? (TODO/FIXME - Kivutar should document this)
* Up : when we press 'Up' on the D-pad while this entry is selected.
* Down : when we press 'Down' on the D-pad while this entry is selected.
* Left : when we press 'Left' on the D-pad while this entry is selected.
* Right : when we press 'Right' on the D-pad while this entry is selected.
* Deferred push : When pressing an entry results in spawning a new list, it waits until the next
* frame to push this onto the stack. This function callback will then be invoked.
* Refresh : What happens when the screen has to be refreshed. Does an entry have internal state
* that needs to be rebuild?
* Get value: Each entry has associated 'text', which we call the value. This function callback
* lets us render that text.
* Get title: Each entry can have a custom 'title'.
* Label: Each entry has a label name. This function callback lets us render that label text.
* Sublabel: each entry has a sublabel, which consists of one or more lines of additional information.
* This function callback lets us render that text.
*/
void menu_cbs_init(void *data,
menu_file_list_cbs_t *cbs,
const char *path, const char *label,
unsigned type, size_t idx)
{
menu_ctx_bind_t bind_info;
const char *repr_label = NULL;
const char *menu_label = NULL;
uint32_t label_hash = 0;
uint32_t menu_label_hash = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
file_list_t *list = (file_list_t*)data;
if (!list)
return;
menu_entries_get_last_stack(NULL, &menu_label, NULL, &enum_idx, NULL);
if (!label || !menu_label)
return;
label_hash = msg_hash_calculate(label);
menu_label_hash = msg_hash_calculate(menu_label);
#ifdef DEBUG_LOG
RARCH_LOG("\n");
#endif
repr_label = (!string_is_empty(label)) ? label : path;
#ifdef DEBUG_LOG
if (cbs && cbs->enum_idx != MSG_UNKNOWN)
RARCH_LOG("\t\t\tenum_idx %d [%s]\n", cbs->enum_idx, msg_hash_to_str(cbs->enum_idx));
#endif
/* It will try to find a corresponding callback function inside
* menu_cbs_ok.c, then map this callback to the entry. */
menu_cbs_init_bind_ok(cbs, path, label, type, idx, label_hash, menu_label_hash);
menu_cbs_init_log(repr_label, "OK", cbs->action_ok_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_cancel.c, then map this callback to the entry. */
menu_cbs_init_bind_cancel(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "CANCEL", cbs->action_cancel_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_scan.c, then map this callback to the entry. */
menu_cbs_init_bind_scan(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "SCAN", cbs->action_scan_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_start.c, then map this callback to the entry. */
menu_cbs_init_bind_start(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "START", cbs->action_start_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_select.c, then map this callback to the entry. */
menu_cbs_init_bind_select(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "SELECT", cbs->action_select_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_info.c, then map this callback to the entry. */
menu_cbs_init_bind_info(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "INFO", cbs->action_info_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_bind_content_list_switch.c, then map this callback to the entry. */
menu_cbs_init_bind_content_list_switch(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "CONTENT SWITCH", cbs->action_content_list_switch_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_up.c, then map this callback to the entry. */
menu_cbs_init_bind_up(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "UP", cbs->action_up_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_down.c, then map this callback to the entry. */
menu_cbs_init_bind_down(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "DOWN", cbs->action_down_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_left.c, then map this callback to the entry. */
menu_cbs_init_bind_left(cbs, path, label, type, idx, menu_label, label_hash);
menu_cbs_init_log(repr_label, "LEFT", cbs->action_left_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_right.c, then map this callback to the entry. */
menu_cbs_init_bind_right(cbs, path, label, type, idx, menu_label, label_hash);
menu_cbs_init_log(repr_label, "RIGHT", cbs->action_right_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_deferred_push.c, then map this callback to the entry. */
menu_cbs_init_bind_deferred_push(cbs, path, label, type, idx, label_hash);
menu_cbs_init_log(repr_label, "DEFERRED PUSH", cbs->action_deferred_push_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_refresh.c, then map this callback to the entry. */
menu_cbs_init_bind_refresh(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "REFRESH", cbs->action_refresh_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_get_string_representation.c, then map this callback to the entry. */
menu_cbs_init_bind_get_string_representation(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "GET VALUE", cbs->action_get_value_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_title.c, then map this callback to the entry. */
menu_cbs_init_bind_title(cbs, path, label, type, idx, label_hash);
menu_cbs_init_log(repr_label, "GET TITLE", cbs->action_get_title_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_label.c, then map this callback to the entry. */
menu_cbs_init_bind_label(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "LABEL", cbs->action_label_ident);
/* It will try to find a corresponding callback function inside
* menu_cbs_sublabel.c, then map this callback to the entry. */
menu_cbs_init_bind_sublabel(cbs, path, label, type, idx);
menu_cbs_init_log(repr_label, "SUBLABEL", cbs->action_sublabel_ident);
bind_info.cbs = cbs;
bind_info.path = path;
bind_info.label = label;
bind_info.type = type;
bind_info.idx = idx;
bind_info.label_hash = label_hash;
menu_driver_ctl(RARCH_MENU_CTL_BIND_INIT, &bind_info);
}
void set_paths_redirect(const char *path)
{
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *info = rarch_system_info_get_ptr();
uint32_t global_library_name_hash = ((global && info->info.library_name &&
(info->info.library_name[0] != '\0'))
? msg_hash_calculate(info->info.library_name) : 0);
if(global_library_name_hash != 0 &&
(global_library_name_hash != MENU_VALUE_NO_CORE))
{
/* per-core saves: append the library_name to the save location */
if (settings->sort_savefiles_enable && global->dir.savefile[0] != '\0')
{
strlcpy(orig_savefile_dir,global->dir.savefile,
sizeof(orig_savefile_dir));
fill_pathname_dir(
global->dir.savefile,
global->dir.savefile,
info->info.library_name,
sizeof(global->dir.savefile));
/* If path doesn't exist, try to create it,
* if everything fails revert to the original path. */
if(!path_is_directory(global->dir.savefile) && global->dir.savefile[0] != '\0')
{
path_mkdir(global->dir.savefile);
if(!path_is_directory(global->dir.savefile))
{
RARCH_LOG("Reverting savefile directory to %s\n", orig_savefile_dir);
strlcpy(global->dir.savefile,
orig_savefile_dir,
sizeof(global->dir.savefile));
}
}
}
/* per-core states: append the library_name to the save location */
if (settings->sort_savestates_enable && global->dir.savestate[0] != '\0')
{
strlcpy(orig_savestate_dir,
global->dir.savestate,
sizeof(orig_savestate_dir));
fill_pathname_dir(global->dir.savestate,
global->dir.savestate,
info->info.library_name,
sizeof(global->dir.savestate));
/* If path doesn't exist, try to create it.
* If everything fails, revert to the original path. */
if(!path_is_directory(global->dir.savestate) && global->dir.savestate[0] != '\0')
{
path_mkdir(global->dir.savestate);
if(!path_is_directory(global->dir.savestate))
{
RARCH_LOG("Reverting savestate directory to %s\n", orig_savestate_dir);
strlcpy(global->dir.savestate,
orig_savestate_dir,
sizeof(global->dir.savestate));
}
}
}
}
if(path_is_directory(global->dir.savefile))
strlcpy(global->name.savefile, global->dir.savefile,
sizeof(global->name.savefile));
if(path_is_directory(global->dir.savestate))
strlcpy(global->name.savestate, global->dir.savestate,
sizeof(global->name.savestate));
if (path_is_directory(global->name.savefile))
{
fill_pathname_dir(global->name.savefile, global->name.base,
".srm", sizeof(global->name.savefile));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVEFILE_TO),
global->name.savefile);
}
if (path_is_directory(global->name.savestate))
{
fill_pathname_dir(global->name.savestate, global->name.base,
".state", sizeof(global->name.savestate));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO),
global->name.savestate);
}
if (path_is_directory(global->name.cheatfile))
{
fill_pathname_dir(global->name.cheatfile, global->name.base,
".state", sizeof(global->name.cheatfile));
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_CHEATFILE_TO),
global->name.cheatfile);
}
}
static int database_cursor_iterate(libretrodb_cursor_t *cur,
database_info_t *db_info)
{
unsigned i;
struct rmsgpack_dom_value item;
const char* str = NULL;
if (libretrodb_cursor_read_item(cur, &item) != 0)
return -1;
if (item.type != RDT_MAP)
{
rmsgpack_dom_value_free(&item);
return 1;
}
db_info->analog_supported = -1;
db_info->rumble_supported = -1;
db_info->coop_supported = -1;
for (i = 0; i < item.val.map.len; i++)
{
uint32_t value = 0;
struct rmsgpack_dom_value *key = &item.val.map.items[i].key;
struct rmsgpack_dom_value *val = &item.val.map.items[i].value;
if (!key || !val)
continue;
str = key->val.string.buff;
value = msg_hash_calculate(str);
switch (value)
{
case DB_CURSOR_SERIAL:
db_info->serial = strdup(val->val.string.buff);
break;
case DB_CURSOR_ROM_NAME:
db_info->rom_name = strdup(val->val.string.buff);
break;
case DB_CURSOR_NAME:
db_info->name = strdup(val->val.string.buff);
break;
case DB_CURSOR_DESCRIPTION:
db_info->description = strdup(val->val.string.buff);
break;
case DB_CURSOR_GENRE:
db_info->genre = strdup(val->val.string.buff);
break;
case DB_CURSOR_PUBLISHER:
db_info->publisher = strdup(val->val.string.buff);
break;
case DB_CURSOR_DEVELOPER:
db_info->developer = string_split(val->val.string.buff, "|");
break;
case DB_CURSOR_ORIGIN:
db_info->origin = strdup(val->val.string.buff);
break;
case DB_CURSOR_FRANCHISE:
db_info->franchise = strdup(val->val.string.buff);
break;
case DB_CURSOR_BBFC_RATING:
db_info->bbfc_rating = strdup(val->val.string.buff);
break;
case DB_CURSOR_ESRB_RATING:
db_info->esrb_rating = strdup(val->val.string.buff);
break;
case DB_CURSOR_ELSPA_RATING:
db_info->elspa_rating = strdup(val->val.string.buff);
break;
case DB_CURSOR_CERO_RATING:
db_info->cero_rating = strdup(val->val.string.buff);
break;
case DB_CURSOR_PEGI_RATING:
db_info->pegi_rating = strdup(val->val.string.buff);
break;
case DB_CURSOR_ENHANCEMENT_HW:
db_info->enhancement_hw = strdup(val->val.string.buff);
break;
case DB_CURSOR_EDGE_MAGAZINE_REVIEW:
db_info->edge_magazine_review = strdup(val->val.string.buff);
break;
case DB_CURSOR_EDGE_MAGAZINE_RATING:
db_info->edge_magazine_rating = val->val.uint_;
break;
case DB_CURSOR_EDGE_MAGAZINE_ISSUE:
db_info->edge_magazine_issue = val->val.uint_;
break;
case DB_CURSOR_FAMITSU_MAGAZINE_RATING:
db_info->famitsu_magazine_rating = val->val.uint_;
break;
case DB_CURSOR_TGDB_RATING:
db_info->tgdb_rating = val->val.uint_;
break;
case DB_CURSOR_MAX_USERS:
db_info->max_users = val->val.uint_;
break;
case DB_CURSOR_RELEASEDATE_MONTH:
db_info->releasemonth = val->val.uint_;
break;
case DB_CURSOR_RELEASEDATE_YEAR:
db_info->releaseyear = val->val.uint_;
break;
case DB_CURSOR_RUMBLE_SUPPORTED:
db_info->rumble_supported = val->val.uint_;
break;
case DB_CURSOR_COOP_SUPPORTED:
db_info->coop_supported = val->val.uint_;
break;
case DB_CURSOR_ANALOG_SUPPORTED:
db_info->analog_supported = val->val.uint_;
break;
case DB_CURSOR_SIZE:
db_info->size = val->val.uint_;
break;
case DB_CURSOR_CHECKSUM_CRC32:
db_info->crc32 = swap_if_little32(*(uint32_t*)val->val.binary.buff);
break;
case DB_CURSOR_CHECKSUM_SHA1:
db_info->sha1 = bin_to_hex_alloc((uint8_t*)val->val.binary.buff, val->val.binary.len);
break;
case DB_CURSOR_CHECKSUM_MD5:
db_info->md5 = bin_to_hex_alloc((uint8_t*)val->val.binary.buff, val->val.binary.len);
break;
default:
RARCH_LOG("Unknown key: %s\n", str);
break;
}
}
rmsgpack_dom_value_free(&item);
return 0;
}
int database_info_build_query(char *s, size_t len,
const char *label, const char *path)
{
uint32_t value = 0;
bool add_quotes = true;
bool add_glob = false;
database_info_build_query_add_bracket_open(s, len);
value = msg_hash_calculate(label);
switch (value)
{
case DB_QUERY_ENTRY:
strlcat(s, "name", len);
break;
case DB_QUERY_ENTRY_PUBLISHER:
strlcat(s, "publisher", len);
break;
case DB_QUERY_ENTRY_DEVELOPER:
strlcat(s, "developer", len);
add_glob = true;
add_quotes = false;
break;
case DB_QUERY_ENTRY_ORIGIN:
strlcat(s, "origin", len);
break;
case DB_QUERY_ENTRY_FRANCHISE:
strlcat(s, "franchise", len);
break;
case DB_QUERY_ENTRY_RATING:
strlcat(s, "esrb_rating", len);
break;
case DB_QUERY_ENTRY_BBFC_RATING:
strlcat(s, "bbfc_rating", len);
break;
case DB_QUERY_ENTRY_ELSPA_RATING:
strlcat(s, "elspa_rating", len);
break;
case DB_QUERY_ENTRY_PEGI_RATING:
strlcat(s, "pegi_rating", len);
break;
case DB_QUERY_ENTRY_CERO_RATING:
strlcat(s, "cero_rating", len);
break;
case DB_QUERY_ENTRY_ENHANCEMENT_HW:
strlcat(s, "enhancement_hw", len);
break;
case DB_QUERY_ENTRY_EDGE_MAGAZINE_RATING:
strlcat(s, "edge_rating", len);
add_quotes = false;
break;
case DB_QUERY_ENTRY_EDGE_MAGAZINE_ISSUE:
strlcat(s, "edge_issue", len);
add_quotes = false;
break;
case DB_QUERY_ENTRY_FAMITSU_MAGAZINE_RATING:
strlcat(s, "famitsu_rating", len);
add_quotes = false;
break;
case DB_QUERY_ENTRY_RELEASEDATE_MONTH:
strlcat(s, "releasemonth", len);
add_quotes = false;
break;
case DB_QUERY_ENTRY_RELEASEDATE_YEAR:
strlcat(s, "releaseyear", len);
add_quotes = false;
break;
case DB_QUERY_ENTRY_MAX_USERS:
strlcat(s, "users", len);
add_quotes = false;
break;
default:
RARCH_LOG("Unknown label: %s\n", label);
break;
}
database_info_build_query_add_colon(s, len);
if (add_glob)
database_info_build_query_add_glob_open(s, len);
if (add_quotes)
database_info_build_query_add_quote(s, len);
strlcat(s, path, len);
if (add_glob)
database_info_build_query_add_glob_close(s, len);
if (add_quotes)
database_info_build_query_add_quote(s, len);
database_info_build_query_add_bracket_close(s, len);
#if 0
RARCH_LOG("query: %s\n", s);
#endif
return 0;
}
static int cb_http_conn_default(void *data_, size_t len)
{
http_handle_t *http = (http_handle_t*)data_;
if (!http)
return -1;
if (!network_init())
return -1;
http->handle = net_http_new(http->connection.handle);
if (!http->handle)
{
RARCH_ERR("Could not create new HTTP session handle.\n");
return -1;
}
http->cb = NULL;
if (http->connection.elem1[0] != '\0')
{
uint32_t label_hash = msg_hash_calculate(http->connection.elem1);
switch (label_hash)
{
case CB_CORE_UPDATER_DOWNLOAD:
http->cb = &cb_core_updater_download;
break;
case CB_CORE_CONTENT_DOWNLOAD:
http->cb = &cb_core_content_download;
break;
case CB_CORE_UPDATER_LIST:
http->cb = &cb_core_updater_list;
break;
case CB_CORE_CONTENT_LIST:
http->cb = &cb_core_content_list;
break;
case CB_UPDATE_ASSETS:
http->cb = &cb_update_assets;
break;
case CB_UPDATE_CORE_INFO_FILES:
http->cb = &cb_update_core_info_files;
break;
case CB_UPDATE_AUTOCONFIG_PROFILES:
http->cb = &cb_update_autoconfig_profiles;
break;
case CB_UPDATE_CHEATS:
http->cb = &cb_update_cheats;
break;
case CB_UPDATE_DATABASES:
http->cb = &cb_update_databases;
break;
case CB_UPDATE_SHADERS_CG:
http->cb = &cb_update_shaders_cg;
break;
case CB_UPDATE_SHADERS_GLSL:
http->cb = &cb_update_shaders_glsl;
break;
case CB_UPDATE_OVERLAYS:
http->cb = &cb_update_overlays;
break;
}
}
return 0;
}
static int menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t *cbs,
const char *label, uint32_t label_hash, const char *menu_label)
{
if (cbs->setting)
{
const char *parent_group = cbs->setting->parent_group;
if (string_is_equal(parent_group, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU))
&& (setting_get_type(cbs->setting) == ST_GROUP))
{
BIND_ACTION_RIGHT(cbs, action_right_scroll);
return 0;
}
}
if (strstr(label, "input_player") && strstr(label, "_joypad_index"))
{
unsigned i;
for (i = 0; i < MAX_USERS; i++)
{
uint32_t label_setting_hash;
char label_setting[128];
label_setting[0] = '\0';
snprintf(label_setting, sizeof(label_setting), "input_player%d_joypad_index", i + 1);
label_setting_hash = msg_hash_calculate(label_setting);
if (label_hash != label_setting_hash)
continue;
BIND_ACTION_RIGHT(cbs, bind_right_generic);
return 0;
}
}
if (string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)))
{
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
return 0;
}
if (strstr(label, "rdb_entry"))
{
BIND_ACTION_RIGHT(cbs, action_right_scroll);
}
else
{
if (cbs->enum_idx != MSG_UNKNOWN)
{
switch (cbs->enum_idx)
{
case MENU_ENUM_LABEL_SUBSYSTEM_ADD:
case MENU_ENUM_LABEL_SUBSYSTEM_LOAD:
case MENU_ENUM_LABEL_CONNECT_NETPLAY_ROOM:
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
break;
case MENU_ENUM_LABEL_CHEAT_DELETE_ALL:
BIND_ACTION_RIGHT(cbs, action_right_cheat_delete_all);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
BIND_ACTION_RIGHT(cbs, action_right_shader_scale_pass);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS:
BIND_ACTION_RIGHT(cbs, action_right_shader_filter_pass);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_DEFAULT_FILTER:
BIND_ACTION_RIGHT(cbs, action_right_shader_filter_default);
break;
case MENU_ENUM_LABEL_SHADER_WATCH_FOR_CHANGES:
BIND_ACTION_RIGHT(cbs, action_right_shader_watch_for_changes);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
BIND_ACTION_RIGHT(cbs, action_right_shader_num_passes);
break;
case MENU_ENUM_LABEL_CHEAT_NUM_PASSES:
BIND_ACTION_RIGHT(cbs, action_right_cheat_num_passes);
break;
case MENU_ENUM_LABEL_SCREEN_RESOLUTION:
BIND_ACTION_RIGHT(cbs, action_right_video_resolution);
break;
case MENU_ENUM_LABEL_OPEN_ARCHIVE_DETECT_CORE:
case MENU_ENUM_LABEL_LOAD_ARCHIVE_DETECT_CORE:
BIND_ACTION_RIGHT(cbs, action_right_scroll);
break;
case MENU_ENUM_LABEL_NO_ITEMS:
case MENU_ENUM_LABEL_NO_PLAYLIST_ENTRIES_AVAILABLE:
if (
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HISTORY_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MUSIC_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_IMAGES_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
)
{
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
}
else
{
BIND_ACTION_RIGHT(cbs, action_right_scroll);
}
break;
case MENU_ENUM_LABEL_START_VIDEO_PROCESSOR:
case MENU_ENUM_LABEL_TAKE_SCREENSHOT:
if ( string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HISTORY_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_ADD_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MUSIC_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_IMAGES_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS_TAB))
)
{
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
break;
}
default:
return -1;
}
}
else
{
return -1;
}
}
return 0;
}
static int menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t *cbs,
const char *label, uint32_t label_hash, const char *menu_label)
{
unsigned i;
if (cbs->setting)
{
const char *parent_group = menu_setting_get_parent_group(cbs->setting);
if (string_is_equal(parent_group, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU))
&& (menu_setting_get_type(cbs->setting) == ST_GROUP))
{
BIND_ACTION_RIGHT(cbs, action_right_scroll);
return 0;
}
}
for (i = 0; i < MAX_USERS; i++)
{
uint32_t label_setting_hash;
char label_setting[PATH_MAX_LENGTH] = {0};
snprintf(label_setting, sizeof(label_setting), "input_player%d_joypad_index", i + 1);
label_setting_hash = msg_hash_calculate(label_setting);
if (label_hash != label_setting_hash)
continue;
BIND_ACTION_RIGHT(cbs, bind_right_generic);
return 0;
}
if (string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)))
{
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
return 0;
}
if (strstr(label, "rdb_entry"))
{
BIND_ACTION_RIGHT(cbs, action_right_scroll);
}
else
{
if (cbs->enum_idx != MSG_UNKNOWN)
{
switch (cbs->enum_idx)
{
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
BIND_ACTION_RIGHT(cbs, action_right_shader_scale_pass);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS:
BIND_ACTION_RIGHT(cbs, action_right_shader_filter_pass);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_DEFAULT_FILTER:
BIND_ACTION_RIGHT(cbs, action_right_shader_filter_default);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
BIND_ACTION_RIGHT(cbs, action_right_shader_num_passes);
break;
case MENU_ENUM_LABEL_CHEAT_NUM_PASSES:
BIND_ACTION_RIGHT(cbs, action_right_cheat_num_passes);
break;
case MENU_ENUM_LABEL_SCREEN_RESOLUTION:
BIND_ACTION_RIGHT(cbs, action_right_video_resolution);
break;
case MENU_ENUM_LABEL_NO_ITEMS:
case MENU_ENUM_LABEL_NO_PLAYLIST_ENTRIES_AVAILABLE:
if ( string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
)
{
BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
break;
}
default:
return -1;
}
}
else
{
return -1;
}
}
return 0;
}
bool task_push_decompress(
const char *source_file,
const char *target_dir,
const char *target_file,
const char *subdir,
const char *valid_ext,
retro_task_callback_t cb,
void *user_data)
{
char tmp[PATH_MAX_LENGTH] = {0};
decompress_state_t *s = NULL;
retro_task_t *t = NULL;
if (string_is_empty(target_dir) || string_is_empty(source_file))
{
RARCH_WARN("[decompress] Empty or null source file or"
" target directory arguments.\n");
return false;
}
/* ZIP or APK only */
if (!path_file_exists(source_file) ||
msg_hash_to_file_type(msg_hash_calculate(path_get_extension(source_file)))
!= FILE_TYPE_COMPRESSED)
{
RARCH_WARN("[decompress] File '%s' does not exist or is not a compressed file.\n",
source_file);
return false;
}
if (!valid_ext || !valid_ext[0])
valid_ext = NULL;
if (task_check_decompress(source_file))
{
RARCH_LOG("[decompress] File '%s' already being decompressed.\n",
source_file);
return false;
}
RARCH_LOG("[decompress] File '%s.\n", source_file);
s = (decompress_state_t*)calloc(1, sizeof(*s));
if (!s)
goto error;
s->source_file = strdup(source_file);
s->target_dir = strdup(target_dir);
s->valid_ext = valid_ext ? strdup(valid_ext) : NULL;
s->zlib.type = ZLIB_TRANSFER_INIT;
t = (retro_task_t*)calloc(1, sizeof(*t));
if (!t)
goto error;
t->state = s;
t->handler = task_decompress_handler;
if (!string_is_empty(subdir))
{
s->subdir = strdup(subdir);
t->handler = task_decompress_handler_subdir;
}
else if (!string_is_empty(target_file))
{
s->target_file = strdup(target_file);
t->handler = task_decompress_handler_target_file;
}
t->callback = cb;
t->user_data = user_data;
snprintf(tmp, sizeof(tmp), "%s '%s'",
msg_hash_to_str(MSG_EXTRACTING), path_basename(source_file));
t->title = strdup(tmp);
task_queue_ctl(TASK_QUEUE_CTL_PUSH, t);
return true;
error:
if (s)
free(s);
return false;
}
