static void history_playlist_push(content_playlist_t *playlist, const char *path, const char *core_path, struct retro_system_info *info) { char tmp[PATH_MAX_LENGTH] = {0}; global_t *global = global_get_ptr(); rarch_system_info_t *system = rarch_system_info_get_ptr(); if (!playlist || (global->core_type == CORE_TYPE_DUMMY) || !info) return; /* Path can be relative here. * Ensure we're pushing absolute path. */ strlcpy(tmp, path, sizeof(tmp)); if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); if (system->no_content || *tmp) content_playlist_push(playlist, *tmp ? tmp : NULL, NULL, core_path, info->library_name, NULL, NULL); }
static void history_playlist_push(content_playlist_t *playlist, const char *path, const char *core_path, struct retro_system_info *info) { char tmp[PATH_MAX_LENGTH]; rarch_system_info_t *system = NULL; runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system); if (!playlist || rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL) || !info) return; /* Path can be relative here. * Ensure we're pushing absolute path. */ strlcpy(tmp, path, sizeof(tmp)); if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); if (system->no_content || *tmp) content_playlist_push(playlist, *tmp ? tmp : NULL, NULL, core_path, info->library_name, NULL, NULL); }
void menu_rom_history_push_current(void *data) { // g_extern.fullpath can be relative here. // Ensure we're pushing absolute path. char tmp[PATH_MAX]; rgui_handle_t *rgui = (rgui_handle_t*)data; strlcpy(tmp, g_extern.fullpath, sizeof(tmp)); if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); if (g_extern.system.no_game || *tmp) menu_rom_history_push(rgui, *tmp ? tmp : NULL, g_settings.libretro, g_extern.system.info.library_name); }
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 void load_dynamic_core(void) { function_t sym = dylib_proc(NULL, "retro_init"); if (sym) { /* Try to verify that -lretro was not linked in from other modules * since loading it dynamically and with -l will fail hard. */ RARCH_ERR("Serious problem. RetroArch wants to load libretro cores" "dyamically, but it is already linked.\n"); RARCH_ERR("This could happen if other modules RetroArch depends on " "link against libretro directly.\n"); RARCH_ERR("Proceeding could cause a crash. Aborting ...\n"); retroarch_fail(1, "init_libretro_sym()"); } if (string_is_empty(path_get(RARCH_PATH_CORE))) { RARCH_ERR("RetroArch is built for dynamic libretro cores, but " "libretro_path is not set. Cannot continue.\n"); retroarch_fail(1, "init_libretro_sym()"); } /* Need to use absolute path for this setting. It can be * saved to content history, and a relative path would * break in that scenario. */ path_resolve_realpath( path_get_ptr(RARCH_PATH_CORE), path_get_realsize(RARCH_PATH_CORE)); RARCH_LOG("Loading dynamic libretro core from: \"%s\"\n", path_get(RARCH_PATH_CORE)); lib_handle = dylib_load(path_get(RARCH_PATH_CORE)); if (!lib_handle) { RARCH_ERR("Failed to open libretro core: \"%s\"\n", path_get(RARCH_PATH_CORE)); RARCH_ERR("Error(s): %s\n", dylib_error()); retroarch_fail(1, "load_dynamic()"); } }
void menu_rom_history_push_current(void) { // g_extern.fullpath can be relative here. // Ensure we're pushing absolute path. char tmp[PATH_MAX]; // We loaded a zip, and fullpath points to the extracted file. // Look at basename instead. if (g_extern.rom_file_temporary) snprintf(tmp, sizeof(tmp), "%s.zip", g_extern.basename); else strlcpy(tmp, g_extern.fullpath, sizeof(tmp)); if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); menu_rom_history_push(*tmp ? tmp : NULL, g_settings.libretro, g_extern.system.info.library_name); }
void menu_content_history_push_current(void) { char tmp[PATH_MAX]; /* g_extern.fullpath can be relative here. * Ensure we're pushing absolute path. */ if (!g_extern.history) return; strlcpy(tmp, g_extern.fullpath, sizeof(tmp)); if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); if (g_extern.system.no_content || *tmp) if (g_extern.history) content_playlist_push(g_extern.history, *tmp ? tmp : NULL, g_settings.libretro, g_extern.system.info.library_name); }
/** * task_load_content: * * Loads content into currently selected core. * Will also optionally push the content entry to the history playlist. * * Returns: true (1) if successful, otherwise false (0). **/ static bool task_load_content(content_ctx_info_t *content_info, content_information_ctx_t *content_ctx, bool launched_from_menu, enum content_mode_load mode, char **error_string) { char name[255]; char msg[255]; name[0] = msg[0] = '\0'; if (!content_load(content_info)) goto error; /* Push entry to top of history playlist */ if (_content_is_inited || content_does_not_need_content()) { char tmp[PATH_MAX_LENGTH]; struct retro_system_info *info = NULL; rarch_system_info_t *sys_info = NULL; tmp[0] = '\0'; runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &sys_info); if (sys_info) info = &sys_info->info; #ifdef HAVE_MENU if (launched_from_menu) menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &info); #endif strlcpy(tmp, path_get(RARCH_PATH_CONTENT), sizeof(tmp)); if (!launched_from_menu) { /* Path can be relative here. * Ensure we're pushing absolute path. */ if (!string_is_empty(tmp)) path_resolve_realpath(tmp, sizeof(tmp)); } if (info && !string_is_empty(tmp)) { const char *core_path = NULL; const char *core_name = NULL; playlist_t *playlist_tmp = g_defaults.content_history; switch (path_is_media_type(tmp)) { case RARCH_CONTENT_MOVIE: #ifdef HAVE_FFMPEG playlist_tmp = g_defaults.video_history; core_name = "movieplayer"; core_path = "builtin"; #endif break; case RARCH_CONTENT_MUSIC: #ifdef HAVE_FFMPEG playlist_tmp = g_defaults.music_history; core_name = "musicplayer"; core_path = "builtin"; #endif break; case RARCH_CONTENT_IMAGE: #ifdef HAVE_IMAGEVIEWER playlist_tmp = g_defaults.image_history; core_name = "imageviewer"; core_path = "builtin"; #endif break; default: core_path = path_get(RARCH_PATH_CORE); core_name = info->library_name; break; } if (mode == CONTENT_MODE_LOAD_FROM_CLI) { settings_t *settings = config_get_ptr(); content_ctx->history_list_enable = settings->history_list_enable; } if ( content_ctx->history_list_enable && playlist_tmp && playlist_push( playlist_tmp, tmp, NULL, core_path, core_name, NULL, NULL) ) playlist_write_file(playlist_tmp); } } return true; error: if (launched_from_menu) { if (!path_is_empty(RARCH_PATH_CONTENT) && !string_is_empty(name)) { snprintf(msg, sizeof(msg), "%s %s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD), name); if (error_string) free(error_string); *error_string = strdup(msg); } } return false; }
static void load_symbols(bool is_dummy) { if (is_dummy) { SYM_DUMMY(retro_init); SYM_DUMMY(retro_deinit); SYM_DUMMY(retro_api_version); SYM_DUMMY(retro_get_system_info); SYM_DUMMY(retro_get_system_av_info); SYM_DUMMY(retro_set_environment); SYM_DUMMY(retro_set_video_refresh); SYM_DUMMY(retro_set_audio_sample); SYM_DUMMY(retro_set_audio_sample_batch); SYM_DUMMY(retro_set_input_poll); SYM_DUMMY(retro_set_input_state); SYM_DUMMY(retro_set_controller_port_device); SYM_DUMMY(retro_reset); SYM_DUMMY(retro_run); SYM_DUMMY(retro_serialize_size); SYM_DUMMY(retro_serialize); SYM_DUMMY(retro_unserialize); SYM_DUMMY(retro_cheat_reset); SYM_DUMMY(retro_cheat_set); SYM_DUMMY(retro_load_game); SYM_DUMMY(retro_load_game_special); SYM_DUMMY(retro_unload_game); SYM_DUMMY(retro_get_region); SYM_DUMMY(retro_get_memory_data); SYM_DUMMY(retro_get_memory_size); } else { #ifdef HAVE_DYNAMIC if (path_is_directory(g_settings.libretro)) { char libretro_core_buffer[PATH_MAX]; if (!find_first_libretro(libretro_core_buffer, sizeof(libretro_core_buffer), g_settings.libretro, g_extern.fullpath)) { RARCH_ERR("libretro_path is a directory, but no valid libretro implementation was found.\n"); rarch_fail(1, "load_dynamic()"); } strlcpy(g_settings.libretro, libretro_core_buffer, sizeof(g_settings.libretro)); } // Need to use absolute path for this setting. It can be saved to ROM history, // and a relative path would break in that scenario. path_resolve_realpath(g_settings.libretro, sizeof(g_settings.libretro)); RARCH_LOG("Loading dynamic libretro from: \"%s\"\n", g_settings.libretro); lib_handle = dylib_load(g_settings.libretro); if (!lib_handle) { RARCH_ERR("Failed to open dynamic library: \"%s\"\n", g_settings.libretro); rarch_fail(1, "load_dynamic()"); } #endif SYM(retro_init); SYM(retro_deinit); SYM(retro_api_version); SYM(retro_get_system_info); SYM(retro_get_system_av_info); SYM(retro_set_environment); SYM(retro_set_video_refresh); SYM(retro_set_audio_sample); SYM(retro_set_audio_sample_batch); SYM(retro_set_input_poll); SYM(retro_set_input_state); SYM(retro_set_controller_port_device); SYM(retro_reset); SYM(retro_run); SYM(retro_serialize_size); SYM(retro_serialize); SYM(retro_unserialize); SYM(retro_cheat_reset); SYM(retro_cheat_set); SYM(retro_load_game); SYM(retro_load_game_special); SYM(retro_unload_game); SYM(retro_get_region); SYM(retro_get_memory_data); SYM(retro_get_memory_size); } }
/** * load_symbols: * @type : Type of core to be loaded. * If CORE_TYPE_DUMMY, will * load dummy symbols. * * Setup libretro callback symbols. **/ static void load_symbols(enum rarch_core_type type) { switch (type) { case CORE_TYPE_PLAIN: { #ifdef HAVE_DYNAMIC settings_t *settings = config_get_ptr(); function_t sym = dylib_proc(NULL, "retro_init"); if (sym) { /* Try to verify that -lretro was not linked in from other modules * since loading it dynamically and with -l will fail hard. */ RARCH_ERR("Serious problem. RetroArch wants to load libretro cores dyamically, but it is already linked.\n"); RARCH_ERR("This could happen if other modules RetroArch depends on link against libretro directly.\n"); RARCH_ERR("Proceeding could cause a crash. Aborting ...\n"); retro_fail(1, "init_libretro_sym()"); } if (!*settings->libretro) { RARCH_ERR("RetroArch is built for dynamic libretro cores, but libretro_path is not set. Cannot continue.\n"); retro_fail(1, "init_libretro_sym()"); } /* Need to use absolute path for this setting. It can be * saved to content history, and a relative path would * break in that scenario. */ path_resolve_realpath(settings->libretro, sizeof(settings->libretro)); RARCH_LOG("Loading dynamic libretro core from: \"%s\"\n", settings->libretro); lib_handle = dylib_load(settings->libretro); if (!lib_handle) { RARCH_ERR("Failed to open libretro core: \"%s\"\n", settings->libretro); RARCH_ERR("Error(s): %s\n", dylib_error()); retro_fail(1, "load_dynamic()"); } #endif } SYMBOL(retro_init); SYMBOL(retro_deinit); SYMBOL(retro_api_version); SYMBOL(retro_get_system_info); SYMBOL(retro_get_system_av_info); SYMBOL(retro_set_environment); SYMBOL(retro_set_video_refresh); SYMBOL(retro_set_audio_sample); SYMBOL(retro_set_audio_sample_batch); SYMBOL(retro_set_input_poll); SYMBOL(retro_set_input_state); SYMBOL(retro_set_controller_port_device); SYMBOL(retro_reset); SYMBOL(retro_run); SYMBOL(retro_serialize_size); SYMBOL(retro_serialize); SYMBOL(retro_unserialize); SYMBOL(retro_cheat_reset); SYMBOL(retro_cheat_set); SYMBOL(retro_load_game); SYMBOL(retro_load_game_special); SYMBOL(retro_unload_game); SYMBOL(retro_get_region); SYMBOL(retro_get_memory_data); SYMBOL(retro_get_memory_size); break; case CORE_TYPE_DUMMY: SYMBOL_DUMMY(retro_init); SYMBOL_DUMMY(retro_deinit); SYMBOL_DUMMY(retro_api_version); SYMBOL_DUMMY(retro_get_system_info); SYMBOL_DUMMY(retro_get_system_av_info); SYMBOL_DUMMY(retro_set_environment); SYMBOL_DUMMY(retro_set_video_refresh); SYMBOL_DUMMY(retro_set_audio_sample); SYMBOL_DUMMY(retro_set_audio_sample_batch); SYMBOL_DUMMY(retro_set_input_poll); SYMBOL_DUMMY(retro_set_input_state); SYMBOL_DUMMY(retro_set_controller_port_device); SYMBOL_DUMMY(retro_reset); SYMBOL_DUMMY(retro_run); SYMBOL_DUMMY(retro_serialize_size); SYMBOL_DUMMY(retro_serialize); SYMBOL_DUMMY(retro_unserialize); SYMBOL_DUMMY(retro_cheat_reset); SYMBOL_DUMMY(retro_cheat_set); SYMBOL_DUMMY(retro_load_game); SYMBOL_DUMMY(retro_load_game_special); SYMBOL_DUMMY(retro_unload_game); SYMBOL_DUMMY(retro_get_region); SYMBOL_DUMMY(retro_get_memory_data); SYMBOL_DUMMY(retro_get_memory_size); break; #ifdef HAVE_FFMPEG case CORE_TYPE_FFMPEG: SYMBOL_FFMPEG(retro_init); SYMBOL_FFMPEG(retro_deinit); SYMBOL_FFMPEG(retro_api_version); SYMBOL_FFMPEG(retro_get_system_info); SYMBOL_FFMPEG(retro_get_system_av_info); SYMBOL_FFMPEG(retro_set_environment); SYMBOL_FFMPEG(retro_set_video_refresh); SYMBOL_FFMPEG(retro_set_audio_sample); SYMBOL_FFMPEG(retro_set_audio_sample_batch); SYMBOL_FFMPEG(retro_set_input_poll); SYMBOL_FFMPEG(retro_set_input_state); SYMBOL_FFMPEG(retro_set_controller_port_device); SYMBOL_FFMPEG(retro_reset); SYMBOL_FFMPEG(retro_run); SYMBOL_FFMPEG(retro_serialize_size); SYMBOL_FFMPEG(retro_serialize); SYMBOL_FFMPEG(retro_unserialize); SYMBOL_FFMPEG(retro_cheat_reset); SYMBOL_FFMPEG(retro_cheat_set); SYMBOL_FFMPEG(retro_load_game); SYMBOL_FFMPEG(retro_load_game_special); SYMBOL_FFMPEG(retro_unload_game); SYMBOL_FFMPEG(retro_get_region); SYMBOL_FFMPEG(retro_get_memory_data); SYMBOL_FFMPEG(retro_get_memory_size); break; #endif case CORE_TYPE_IMAGEVIEWER: #ifdef HAVE_IMAGEVIEWER SYMBOL_IMAGEVIEWER(retro_init); SYMBOL_IMAGEVIEWER(retro_deinit); SYMBOL_IMAGEVIEWER(retro_api_version); SYMBOL_IMAGEVIEWER(retro_get_system_info); SYMBOL_IMAGEVIEWER(retro_get_system_av_info); SYMBOL_IMAGEVIEWER(retro_set_environment); SYMBOL_IMAGEVIEWER(retro_set_video_refresh); SYMBOL_IMAGEVIEWER(retro_set_audio_sample); SYMBOL_IMAGEVIEWER(retro_set_audio_sample_batch); SYMBOL_IMAGEVIEWER(retro_set_input_poll); SYMBOL_IMAGEVIEWER(retro_set_input_state); SYMBOL_IMAGEVIEWER(retro_set_controller_port_device); SYMBOL_IMAGEVIEWER(retro_reset); SYMBOL_IMAGEVIEWER(retro_run); SYMBOL_IMAGEVIEWER(retro_serialize_size); SYMBOL_IMAGEVIEWER(retro_serialize); SYMBOL_IMAGEVIEWER(retro_unserialize); SYMBOL_IMAGEVIEWER(retro_cheat_reset); SYMBOL_IMAGEVIEWER(retro_cheat_set); SYMBOL_IMAGEVIEWER(retro_load_game); SYMBOL_IMAGEVIEWER(retro_load_game_special); SYMBOL_IMAGEVIEWER(retro_unload_game); SYMBOL_IMAGEVIEWER(retro_get_region); SYMBOL_IMAGEVIEWER(retro_get_memory_data); SYMBOL_IMAGEVIEWER(retro_get_memory_size); #endif break; } }
/** * video_shader_write_conf_cgp: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Saves preset and all associated state (passes, * textures, imports, etc) to disk. **/ void video_shader_write_conf_cgp(config_file_t *conf, struct video_shader *shader) { unsigned i; config_set_int(conf, "shaders", shader->passes); if (shader->feedback_pass >= 0) config_set_int(conf, "feedback_pass", shader->feedback_pass); for (i = 0; i < shader->passes; i++) { char key[64]; char tmp[PATH_MAX_LENGTH]; const struct video_shader_pass *pass = &shader->pass[i]; key[0] = '\0'; snprintf(key, sizeof(key), "shader%u", i); strlcpy(tmp, pass->source.path, sizeof(tmp)); if (!path_is_absolute(tmp)) path_resolve_realpath(tmp, sizeof(tmp)); config_set_string(conf, key, tmp); if (pass->filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "filter_linear%u", i); config_set_bool(conf, key, pass->filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "wrap_mode%u", i); config_set_string(conf, key, wrap_mode_to_str(pass->wrap)); if (pass->frame_count_mod) { snprintf(key, sizeof(key), "frame_count_mod%u", i); config_set_int(conf, key, pass->frame_count_mod); } snprintf(key, sizeof(key), "mipmap_input%u", i); config_set_bool(conf, key, pass->mipmap); snprintf(key, sizeof(key), "alias%u", i); config_set_string(conf, key, pass->alias); shader_write_fbo(conf, &pass->fbo, i); } if (shader->num_parameters) { char parameters[4096]; parameters[0] = '\0'; strlcpy(parameters, shader->parameters[0].id, sizeof(parameters)); for (i = 1; i < shader->num_parameters; i++) { /* O(n^2), but number of parameters is very limited. */ strlcat(parameters, ";", sizeof(parameters)); strlcat(parameters, shader->parameters[i].id, sizeof(parameters)); } config_set_string(conf, "parameters", parameters); for (i = 0; i < shader->num_parameters; i++) config_set_float(conf, shader->parameters[i].id, shader->parameters[i].current); } if (shader->luts) { char textures[4096]; textures[0] = '\0'; strlcpy(textures, shader->lut[0].id, sizeof(textures)); for (i = 1; i < shader->luts; i++) { /* O(n^2), but number of textures is very limited. */ strlcat(textures, ";", sizeof(textures)); strlcat(textures, shader->lut[i].id, sizeof(textures)); } config_set_string(conf, "textures", textures); for (i = 0; i < shader->luts; i++) { char key[64]; key[0] = '\0'; config_set_string(conf, shader->lut[i].id, shader->lut[i].path); if (shader->lut[i].filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "%s_linear", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "%s_wrap_mode", shader->lut[i].id); config_set_string(conf, key, wrap_mode_to_str(shader->lut[i].wrap)); snprintf(key, sizeof(key), "%s_mipmap", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].mipmap); } } if (*shader->script_path) config_set_string(conf, "import_script", shader->script_path); if (*shader->script_class) config_set_string(conf, "import_script_class", shader->script_class); if (shader->variables) { char variables[4096]; variables[0] = '\0'; strlcpy(variables, shader->variable[0].id, sizeof(variables)); for (i = 1; i < shader->variables; i++) { strlcat(variables, ";", sizeof(variables)); strlcat(variables, shader->variable[i].id, sizeof(variables)); } config_set_string(conf, "imports", variables); for (i = 0; i < shader->variables; i++) shader_write_variable(conf, &shader->variable[i]); } }
/** * video_shader_parse_textures: * @conf : Preset file to read from. * @shader : Shader pass handle. * * Parses shader textures. * * Returns: true (1) if successful, otherwise false (0). **/ static bool video_shader_parse_textures(config_file_t *conf, struct video_shader *shader) { char textures[1024]; const char *id = NULL; char *save = NULL; char tmp_path[PATH_MAX_LENGTH]; textures[0] = '\0'; if (!config_get_array(conf, "textures", textures, sizeof(textures))) return true; for (id = strtok_r(textures, ";", &save); id && shader->luts < GFX_MAX_TEXTURES; shader->luts++, id = strtok_r(NULL, ";", &save)) { char id_filter[64]; char id_wrap[64]; char wrap_mode[64]; char id_mipmap[64]; bool mipmap = false; bool smooth = false; id_filter[0] = id_wrap[0] = wrap_mode[0] = id_mipmap[0] = '\0'; if (!config_get_array(conf, id, shader->lut[shader->luts].path, sizeof(shader->lut[shader->luts].path))) { RARCH_ERR("Cannot find path to texture \"%s\" ...\n", id); return false; } strlcpy(tmp_path, shader->lut[shader->luts].path, sizeof(tmp_path)); path_resolve_realpath(tmp_path, sizeof(tmp_path)); if (path_file_exists(tmp_path)) { strlcpy(shader->lut[shader->luts].path, tmp_path, sizeof(shader->lut[shader->luts].path)); } strlcpy(shader->lut[shader->luts].id, id, sizeof(shader->lut[shader->luts].id)); snprintf(id_filter, sizeof(id_filter), "%s_linear", id); if (config_get_bool(conf, id_filter, &smooth)) shader->lut[shader->luts].filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST; else shader->lut[shader->luts].filter = RARCH_FILTER_UNSPEC; snprintf(id_wrap, sizeof(id_wrap), "%s_wrap_mode", id); if (config_get_array(conf, id_wrap, wrap_mode, sizeof(wrap_mode))) shader->lut[shader->luts].wrap = wrap_str_to_mode(wrap_mode); snprintf(id_mipmap, sizeof(id_mipmap), "%s_mipmap", id); if (config_get_bool(conf, id_mipmap, &mipmap)) shader->lut[shader->luts].mipmap = mipmap; else shader->lut[shader->luts].mipmap = false; } return true; }
/** * video_shader_parse_pass: * @conf : Preset file to read from. * @pass : Shader passes handle. * @i : Index of shader pass. * * Parses shader pass from preset file. * * Returns: true (1) if successful, otherwise false (0). **/ static bool video_shader_parse_pass(config_file_t *conf, struct video_shader_pass *pass, unsigned i) { char tmp_str[PATH_MAX_LENGTH]; char tmp_path[PATH_MAX_LENGTH]; char shader_name[64]; char filter_name_buf[64]; char wrap_name_buf[64]; char wrap_mode[64]; char frame_count_mod_buf[64]; char srgb_output_buf[64]; char fp_fbo_buf[64]; char mipmap_buf[64]; char alias_buf[64]; char scale_name_buf[64]; char attr_name_buf[64]; char scale_type[64]; char scale_type_x[64]; char scale_type_y[64]; char frame_count_mod[64]; struct gfx_fbo_scale *scale = NULL; bool tmp_bool = false; float fattr = 0.0f; int iattr = 0; fp_fbo_buf[0] = mipmap_buf[0] = alias_buf[0] = scale_name_buf[0] = attr_name_buf[0] = scale_type[0] = scale_type_x[0] = scale_type_y[0] = frame_count_mod[0] = tmp_str[0] = shader_name[0] = filter_name_buf[0] = wrap_name_buf[0] = wrap_mode[0] = frame_count_mod_buf[0] = '\0'; srgb_output_buf[0] = '\0'; /* Source */ snprintf(shader_name, sizeof(shader_name), "shader%u", i); if (!config_get_path(conf, shader_name, tmp_str, sizeof(tmp_str))) { RARCH_ERR("Couldn't parse shader source (%s).\n", shader_name); return false; } strlcpy(tmp_path, tmp_str, sizeof(tmp_path)); path_resolve_realpath(tmp_path, sizeof(tmp_path)); if (!path_file_exists(tmp_path)) strlcpy(pass->source.path, tmp_str, sizeof(pass->source.path)); else strlcpy(pass->source.path, tmp_path, sizeof(pass->source.path)); /* Smooth */ snprintf(filter_name_buf, sizeof(filter_name_buf), "filter_linear%u", i); if (config_get_bool(conf, filter_name_buf, &tmp_bool)) { bool smooth = tmp_bool; pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST; } else pass->filter = RARCH_FILTER_UNSPEC; /* Wrapping mode */ snprintf(wrap_name_buf, sizeof(wrap_name_buf), "wrap_mode%u", i); if (config_get_array(conf, wrap_name_buf, wrap_mode, sizeof(wrap_mode))) pass->wrap = wrap_str_to_mode(wrap_mode); /* Frame count mod */ snprintf(frame_count_mod_buf, sizeof(frame_count_mod_buf), "frame_count_mod%u", i); if (config_get_array(conf, frame_count_mod_buf, frame_count_mod, sizeof(frame_count_mod))) pass->frame_count_mod = strtoul(frame_count_mod, NULL, 0); /* FBO types and mipmapping */ snprintf(srgb_output_buf, sizeof(srgb_output_buf), "srgb_framebuffer%u", i); if (config_get_bool(conf, srgb_output_buf, &tmp_bool)) pass->fbo.srgb_fbo = tmp_bool; snprintf(fp_fbo_buf, sizeof(fp_fbo_buf), "float_framebuffer%u", i); if (config_get_bool(conf, fp_fbo_buf, &tmp_bool)) pass->fbo.fp_fbo = tmp_bool; snprintf(mipmap_buf, sizeof(mipmap_buf), "mipmap_input%u", i); if (config_get_bool(conf, mipmap_buf, &tmp_bool)) pass->mipmap = tmp_bool; snprintf(alias_buf, sizeof(alias_buf), "alias%u", i); if (!config_get_array(conf, alias_buf, pass->alias, sizeof(pass->alias))) *pass->alias = '\0'; /* Scale */ scale = &pass->fbo; snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type%u", i); config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type)); snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_x%u", i); config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x)); snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_y%u", i); config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y)); if (!*scale_type && !*scale_type_x && !*scale_type_y) return true; if (*scale_type) { strlcpy(scale_type_x, scale_type, sizeof(scale_type_x)); strlcpy(scale_type_y, scale_type, sizeof(scale_type_y)); } scale->valid = true; scale->type_x = RARCH_SCALE_INPUT; scale->type_y = RARCH_SCALE_INPUT; scale->scale_x = 1.0; scale->scale_y = 1.0; if (*scale_type_x) { uint32_t scale_type_x_hash = djb2_calculate(scale_type_x); switch (scale_type_x_hash) { case SCALE_TYPE_SOURCE: scale->type_x = RARCH_SCALE_INPUT; break; case SCALE_TYPE_VIEWPORT: scale->type_x = RARCH_SCALE_VIEWPORT; break; case SCALE_TYPE_ABSOLUTE: scale->type_x = RARCH_SCALE_ABSOLUTE; break; default: RARCH_ERR("Invalid attribute.\n"); return false; } } if (*scale_type_y) { uint32_t scale_type_y_hash = djb2_calculate(scale_type_y); switch (scale_type_y_hash) { case SCALE_TYPE_SOURCE: scale->type_y = RARCH_SCALE_INPUT; break; case SCALE_TYPE_VIEWPORT: scale->type_y = RARCH_SCALE_VIEWPORT; break; case SCALE_TYPE_ABSOLUTE: scale->type_y = RARCH_SCALE_ABSOLUTE; break; default: RARCH_ERR("Invalid attribute.\n"); return false; } } snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i); if (scale->type_x == RARCH_SCALE_ABSOLUTE) { if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_x = iattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i); if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_x = iattr; } } else { if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_x = fattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i); if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_x = fattr; } } snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i); if (scale->type_y == RARCH_SCALE_ABSOLUTE) { if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_y = iattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i); if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_y = iattr; } } else { if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_y = fattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i); if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_y = fattr; } } return true; }
static bool content_load_wrapper( content_ctx_info_t *content_info, bool launched_from_menu) { char name[PATH_MAX_LENGTH]; char msg[PATH_MAX_LENGTH]; char *fullpath = NULL; runloop_ctl(RUNLOOP_CTL_GET_CONTENT_PATH, &fullpath); #ifdef HAVE_MENU if (launched_from_menu) { /* redraw menu frame */ menu_display_set_msg_force(true); menu_driver_ctl(RARCH_MENU_CTL_RENDER, NULL); fill_pathname_base(name, fullpath, sizeof(name)); } #endif if (!content_load(content_info)) goto error; if (launched_from_menu) { /** Show loading OSD message */ if (*fullpath) { snprintf(msg, sizeof(msg), "INFO - Loading %s ...", name); runloop_msg_queue_push(msg, 1, 1, false); } } /* Push entry to top of history playlist */ if (content_is_inited() || content_does_not_need_content()) { char tmp[PATH_MAX_LENGTH]; struct retro_system_info *info = NULL; rarch_system_info_t *system = NULL; runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system); if (system) info = &system->info; #ifdef HAVE_MENU if (launched_from_menu) menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &info); #endif strlcpy(tmp, fullpath, sizeof(tmp)); if (!launched_from_menu) { /* Path can be relative here. * Ensure we're pushing absolute path. */ if (*tmp) path_resolve_realpath(tmp, sizeof(tmp)); } if (info && *tmp) { content_push_to_history_playlist( true, tmp, info); playlist_write_file(g_defaults.history); } } return true; error: if (launched_from_menu) { if (!string_is_empty(fullpath) && !string_is_empty(name)) { snprintf(msg, sizeof(msg), "Failed to load %s.\n", name); runloop_msg_queue_push(msg, 1, 90, false); } } return false; }
/** * video_shader_parse_pass: * @conf : Preset file to read from. * @pass : Shader passes handle. * @i : Index of shader pass. * * Parses shader pass from preset file. * * Returns: true (1) if successful, otherwise false (0). **/ static bool video_shader_parse_pass(config_file_t *conf, struct video_shader_pass *pass, unsigned i) { char shader_name[64]; char filter_name_buf[64]; char wrap_name_buf[64]; char wrap_mode[64]; char frame_count_mod_buf[64]; char srgb_output_buf[64]; char fp_fbo_buf[64]; char mipmap_buf[64]; char alias_buf[64]; char scale_name_buf[64]; char attr_name_buf[64]; char scale_type[64]; char scale_type_x[64]; char scale_type_y[64]; char frame_count_mod[64]; size_t path_size = PATH_MAX_LENGTH * sizeof(char); char *tmp_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); char *tmp_path = NULL; struct gfx_fbo_scale *scale = NULL; bool tmp_bool = false; float fattr = 0.0f; int iattr = 0; fp_fbo_buf[0] = mipmap_buf[0] = alias_buf[0] = scale_name_buf[0] = attr_name_buf[0] = scale_type[0] = scale_type_x[0] = scale_type_y[0] = frame_count_mod[0] = tmp_str[0] = shader_name[0] = filter_name_buf[0] = wrap_name_buf[0] = wrap_mode[0] = frame_count_mod_buf[0] = '\0'; srgb_output_buf[0] = '\0'; /* Source */ snprintf(shader_name, sizeof(shader_name), "shader%u", i); if (!config_get_path(conf, shader_name, tmp_str, path_size)) { RARCH_ERR("Couldn't parse shader source (%s).\n", shader_name); goto error; } tmp_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); strlcpy(tmp_path, tmp_str, path_size); path_resolve_realpath(tmp_path, path_size); if (!filestream_exists(tmp_path)) strlcpy(pass->source.path, tmp_str, sizeof(pass->source.path)); else strlcpy(pass->source.path, tmp_path, sizeof(pass->source.path)); free(tmp_path); /* Smooth */ snprintf(filter_name_buf, sizeof(filter_name_buf), "filter_linear%u", i); if (config_get_bool(conf, filter_name_buf, &tmp_bool)) { bool smooth = tmp_bool; pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST; } else pass->filter = RARCH_FILTER_UNSPEC; /* Wrapping mode */ snprintf(wrap_name_buf, sizeof(wrap_name_buf), "wrap_mode%u", i); if (config_get_array(conf, wrap_name_buf, wrap_mode, sizeof(wrap_mode))) pass->wrap = wrap_str_to_mode(wrap_mode); /* Frame count mod */ snprintf(frame_count_mod_buf, sizeof(frame_count_mod_buf), "frame_count_mod%u", i); if (config_get_array(conf, frame_count_mod_buf, frame_count_mod, sizeof(frame_count_mod))) pass->frame_count_mod = (unsigned)strtoul(frame_count_mod, NULL, 0); /* FBO types and mipmapping */ snprintf(srgb_output_buf, sizeof(srgb_output_buf), "srgb_framebuffer%u", i); if (config_get_bool(conf, srgb_output_buf, &tmp_bool)) pass->fbo.srgb_fbo = tmp_bool; snprintf(fp_fbo_buf, sizeof(fp_fbo_buf), "float_framebuffer%u", i); if (config_get_bool(conf, fp_fbo_buf, &tmp_bool)) pass->fbo.fp_fbo = tmp_bool; snprintf(mipmap_buf, sizeof(mipmap_buf), "mipmap_input%u", i); if (config_get_bool(conf, mipmap_buf, &tmp_bool)) pass->mipmap = tmp_bool; snprintf(alias_buf, sizeof(alias_buf), "alias%u", i); if (!config_get_array(conf, alias_buf, pass->alias, sizeof(pass->alias))) *pass->alias = '\0'; /* Scale */ scale = &pass->fbo; snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type%u", i); config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type)); snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_x%u", i); config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x)); snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_y%u", i); config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y)); if (!*scale_type && !*scale_type_x && !*scale_type_y) { free(tmp_str); return true; } if (*scale_type) { strlcpy(scale_type_x, scale_type, sizeof(scale_type_x)); strlcpy(scale_type_y, scale_type, sizeof(scale_type_y)); } scale->valid = true; scale->type_x = RARCH_SCALE_INPUT; scale->type_y = RARCH_SCALE_INPUT; scale->scale_x = 1.0; scale->scale_y = 1.0; if (*scale_type_x) { if (string_is_equal(scale_type_x, "source")) scale->type_x = RARCH_SCALE_INPUT; else if (string_is_equal(scale_type_x, "viewport")) scale->type_x = RARCH_SCALE_VIEWPORT; else if (string_is_equal(scale_type_x, "absolute")) scale->type_x = RARCH_SCALE_ABSOLUTE; else { RARCH_ERR("Invalid attribute.\n"); goto error; } } if (*scale_type_y) { if (string_is_equal(scale_type_y, "source")) scale->type_y = RARCH_SCALE_INPUT; else if (string_is_equal(scale_type_y, "viewport")) scale->type_y = RARCH_SCALE_VIEWPORT; else if (string_is_equal(scale_type_y, "absolute")) scale->type_y = RARCH_SCALE_ABSOLUTE; else { RARCH_ERR("Invalid attribute.\n"); goto error; } } snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i); if (scale->type_x == RARCH_SCALE_ABSOLUTE) { if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_x = iattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i); if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_x = iattr; } } else { if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_x = fattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i); if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_x = fattr; } } snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i); if (scale->type_y == RARCH_SCALE_ABSOLUTE) { if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_y = iattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i); if (config_get_int(conf, attr_name_buf, &iattr)) scale->abs_y = iattr; } } else { if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_y = fattr; else { snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i); if (config_get_float(conf, attr_name_buf, &fattr)) scale->scale_y = fattr; } } free(tmp_str); return true; error: free(tmp_str); return false; }
/** * task_load_content: * * Loads content into currently selected core. * Will also optionally push the content entry to the history playlist. * * Returns: true (1) if successful, otherwise false (0). **/ static bool task_load_content(content_ctx_info_t *content_info, bool launched_from_menu, enum content_mode_load mode) { char name[256]; char msg[256]; name[0] = msg[0] = '\0'; if (launched_from_menu) { #ifdef HAVE_MENU /* redraw menu frame */ menu_display_set_msg_force(true); menu_driver_ctl(RARCH_MENU_CTL_RENDER, NULL); if (!path_is_empty(RARCH_PATH_CONTENT)) fill_pathname_base(name, path_get(RARCH_PATH_CONTENT), sizeof(name)); #endif /** Show loading OSD message */ if (!string_is_empty(path_get(RARCH_PATH_CONTENT))) { snprintf(msg, sizeof(msg), "%s %s ...", msg_hash_to_str(MSG_LOADING), name); runloop_msg_queue_push(msg, 2, 1, true); } } if (!content_load(content_info)) goto error; /* Push entry to top of history playlist */ if (content_is_inited() || content_does_not_need_content()) { char tmp[PATH_MAX_LENGTH]; struct retro_system_info *info = NULL; rarch_system_info_t *system = NULL; tmp[0] = '\0'; runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system); if (system) info = &system->info; #ifdef HAVE_MENU if (launched_from_menu) menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &info); #endif strlcpy(tmp, path_get(RARCH_PATH_CONTENT), sizeof(tmp)); if (!launched_from_menu) { /* Path can be relative here. * Ensure we're pushing absolute path. */ if (!string_is_empty(tmp)) path_resolve_realpath(tmp, sizeof(tmp)); } if (info && *tmp) { const char *core_path = NULL; const char *core_name = NULL; playlist_t *playlist_tmp = g_defaults.content_history; switch (path_is_media_type(tmp)) { case RARCH_CONTENT_MOVIE: #ifdef HAVE_FFMPEG playlist_tmp = g_defaults.video_history; core_name = "movieplayer"; core_path = "builtin"; #endif break; case RARCH_CONTENT_MUSIC: #ifdef HAVE_FFMPEG playlist_tmp = g_defaults.music_history; core_name = "musicplayer"; core_path = "builtin"; #endif break; case RARCH_CONTENT_IMAGE: #ifdef HAVE_IMAGEVIEWER playlist_tmp = g_defaults.image_history; core_name = "imageviewer"; core_path = "builtin"; #endif break; default: core_path = path_get(RARCH_PATH_CORE); core_name = info->library_name; break; } if (content_push_to_history_playlist(playlist_tmp, tmp, core_name, core_path)) playlist_write_file(playlist_tmp); } } return true; error: if (launched_from_menu) { if (!path_is_empty(RARCH_PATH_CONTENT) && !string_is_empty(name)) { snprintf(msg, sizeof(msg), "%s %s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD), name); runloop_msg_queue_push(msg, 2, 90, true); } } return false; }