/** * video_shader_parse_imports: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Resolves import parameters belonging to shaders. * * Returns: true (1) if successful, otherwise false (0). **/ static bool video_shader_parse_imports(config_file_t *conf, struct video_shader *shader) { const char *id = NULL; char *save = NULL; char imports[1024] = {0}; if (!config_get_array(conf, "imports", imports, sizeof(imports))) return true; for (id = strtok_r(imports, ";", &save); id && shader->variables < GFX_MAX_VARIABLES; shader->variables++, id = strtok_r(NULL, ";", &save)) { uint32_t semantic_hash; char semantic_buf[64] = {0}; char wram_buf[64] = {0}; char input_slot_buf[64] = {0}; char mask_buf[64] = {0}; char equal_buf[64] = {0}; char semantic[64] = {0}; unsigned addr = 0; unsigned mask = 0; unsigned equal = 0; struct state_tracker_uniform_info *var = &shader->variable[shader->variables]; strlcpy(var->id, id, sizeof(var->id)); snprintf(semantic_buf, sizeof(semantic_buf), "%s_semantic", id); snprintf(wram_buf, sizeof(wram_buf), "%s_wram", id); snprintf(input_slot_buf, sizeof(input_slot_buf), "%s_input_slot", id); snprintf(mask_buf, sizeof(mask_buf), "%s_mask", id); snprintf(equal_buf, sizeof(equal_buf), "%s_equal", id); if (!config_get_array(conf, semantic_buf, semantic, sizeof(semantic))) { RARCH_ERR("No semantic for import variable.\n"); return false; } semantic_hash = djb2_calculate(semantic); switch (semantic_hash) { case SEMANTIC_CAPTURE: var->type = RARCH_STATE_CAPTURE; break; case SEMANTIC_TRANSITION: var->type = RARCH_STATE_TRANSITION; break; case SEMANTIC_TRANSITION_COUNT: var->type = RARCH_STATE_TRANSITION_COUNT; break; case SEMANTIC_CAPTURE_PREVIOUS: var->type = RARCH_STATE_CAPTURE_PREV; break; case SEMANTIC_TRANSITION_PREVIOUS: var->type = RARCH_STATE_TRANSITION_PREV; break; case SEMANTIC_PYTHON: var->type = RARCH_STATE_PYTHON; break; default: RARCH_ERR("Invalid semantic.\n"); return false; } if (var->type != RARCH_STATE_PYTHON) { unsigned input_slot = 0; if (config_get_uint(conf, input_slot_buf, &input_slot)) { switch (input_slot) { case 1: var->ram_type = RARCH_STATE_INPUT_SLOT1; break; case 2: var->ram_type = RARCH_STATE_INPUT_SLOT2; break; default: RARCH_ERR("Invalid input slot for import.\n"); return false; } } else if (config_get_hex(conf, wram_buf, &addr)) { var->ram_type = RARCH_STATE_WRAM; var->addr = addr; } else { RARCH_ERR("No address assigned to semantic.\n"); return false; } } if (config_get_hex(conf, mask_buf, &mask)) var->mask = mask; if (config_get_hex(conf, equal_buf, &equal)) var->equal = equal; } config_get_path(conf, "import_script", shader->script_path, sizeof(shader->script_path)); config_get_array(conf, "import_script_class", shader->script_class, sizeof(shader->script_class)); return true; }
static bool ffmpeg_init_config(struct ff_config_param *params, const char *config) { params->out_pix_fmt = PIX_FMT_NONE; params->scale_factor = 1; params->threads = 1; params->frame_drop_ratio = 1; if (!config) return true; params->conf = config_file_new(config); if (!params->conf) { RARCH_ERR("Failed to load FFmpeg config \"%s\".\n", config); return false; } config_get_array(params->conf, "vcodec", params->vcodec, sizeof(params->vcodec)); config_get_array(params->conf, "acodec", params->acodec, sizeof(params->acodec)); config_get_array(params->conf, "format", params->format, sizeof(params->format)); config_get_uint(params->conf, "threads", ¶ms->threads); if (!config_get_uint(params->conf, "frame_drop_ratio", ¶ms->frame_drop_ratio) || !params->frame_drop_ratio) params->frame_drop_ratio = 1; if (!config_get_bool(params->conf, "audio_enable", ¶ms->audio_enable)) params->audio_enable = true; config_get_uint(params->conf, "sample_rate", ¶ms->sample_rate); config_get_uint(params->conf, "scale_factor", ¶ms->scale_factor); params->audio_qscale = config_get_int(params->conf, "audio_global_quality", ¶ms->audio_global_quality); config_get_int(params->conf, "audio_bit_rate", ¶ms->audio_bit_rate); params->video_qscale = config_get_int(params->conf, "video_global_quality", ¶ms->video_global_quality); config_get_int(params->conf, "video_bit_rate", ¶ms->video_bit_rate); char pix_fmt[64] = {0}; if (config_get_array(params->conf, "pix_fmt", pix_fmt, sizeof(pix_fmt))) { params->out_pix_fmt = av_get_pix_fmt(pix_fmt); if (params->out_pix_fmt == PIX_FMT_NONE) { RARCH_ERR("Cannot find pix_fmt \"%s\".\n", pix_fmt); return false; } } struct config_file_entry entry; if (!config_get_entry_list_head(params->conf, &entry)) return true; do { if (strstr(entry.key, "video_") == entry.key) { const char *key = entry.key + strlen("video_"); av_dict_set(¶ms->video_opts, key, entry.value, 0); } else if (strstr(entry.key, "audio_") == entry.key) { const char *key = entry.key + strlen("audio_"); av_dict_set(¶ms->audio_opts, key, entry.value, 0); } } while (config_get_entry_list_next(&entry)); return true; }
static void command_task(struct ETSEventTag *event) { switch(event->sig) { case(command_task_reset): { reset(); break; } case(command_task_uart_bridge): { background_task_bridge_uart(); stat_update_uart++; break; } case(command_task_init_i2c_sensors): { if(i2c_sensors_init()) dispatch_post_command(command_task_init_i2c_sensors); break; } case(command_task_periodic_i2c_sensors): { i2c_sensors_periodic(); break; } case(command_task_init_displays): { uint32_t now = system_get_time(); display_init(); stat_display_init_time_us = system_get_time() - now; break; } case(command_task_received_command): { app_action_t action; if(lwip_if_received_tcp(&command_socket)) stat_update_command_tcp++; if(lwip_if_received_udp(&command_socket)) stat_update_command_udp++; if(lwip_if_send_buffer_locked(&command_socket)) { stat_cmd_send_buffer_overflow++; string_clear(&command_socket_receive_buffer); lwip_if_receive_buffer_unlock(&command_socket); break; } string_clear(&command_socket_send_buffer); action = application_content(&command_socket_receive_buffer, &command_socket_send_buffer); string_clear(&command_socket_receive_buffer); lwip_if_receive_buffer_unlock(&command_socket); if(action == app_action_empty) { string_clear(&command_socket_send_buffer); string_append(&command_socket_send_buffer, "> empty command\n"); } if(action == app_action_disconnect) { string_clear(&command_socket_send_buffer); string_append(&command_socket_send_buffer, "> disconnect\n"); } if(action == app_action_reset) { string_clear(&command_socket_send_buffer); string_append(&command_socket_send_buffer, "> reset\n"); } if(!lwip_if_send(&command_socket)) log("lwip send failed\n"); if(action == app_action_disconnect) lwip_if_close(&command_socket); /* * === ugly workaround === * * For tcp connections we can use the "sent" callback to make sure all * of our data has been sent before rebooting. For udp there is no such * callback and waiting for it to happen does not work (need a return to * SDK code to achieve it). So lwip_if_reboot will take care for it itself * when possible (tcp), otherwise (udp) it will return false here and the * application needs to finish the operation via a task call. */ if(action == app_action_reset) if(!lwip_if_reboot(&command_socket)) dispatch_post_command(command_task_reset); break; } case(command_task_display_update): { stat_update_display++; if(display_periodic()) dispatch_post_command(command_task_display_update); break; } case(command_task_fallback_wlan): { config_wlan_mode_t wlan_mode; unsigned int wlan_mode_int; if(config_get_uint("wlan.mode", &wlan_mode_int, -1, -1)) wlan_mode = (config_wlan_mode_t)wlan_mode_int; else wlan_mode = config_wlan_mode_client; if(wlan_mode == config_wlan_mode_client) { wlan_mode_int = config_wlan_mode_ap; config_open_write(); config_set_uint("wlan.mode", wlan_mode_int, -1, -1); config_close_write(); config_get_uint("wlan.mode", &wlan_mode_int, -1, -1); wlan_init(); } break; } case(command_task_update_time): { time_periodic(); break; } case(command_task_run_sequencer): { sequencer_run(); break; } case(command_task_alert_association): { if((assoc_alert.io >= 0) && (assoc_alert.pin >= 0)) io_trigger_pin((string_t *)0, assoc_alert.io, assoc_alert.pin, io_trigger_on); break; } case(command_task_alert_disassociation): { if((assoc_alert.io >= 0) && (assoc_alert.pin >= 0)) io_trigger_pin((string_t *)0, assoc_alert.io, assoc_alert.pin, io_trigger_off); break; } case(command_task_alert_status): { if((trigger_alert.io >= 0) && (trigger_alert.pin >= 0)) io_trigger_pin((string_t *)0, trigger_alert.io, trigger_alert.pin, io_trigger_on); break; } } }
static core_info_list_t *core_info_list_new(const char *path, const char *libretro_info_dir, const char *exts, bool dir_show_hidden_files) { size_t i; core_info_t *core_info = NULL; core_info_list_t *core_info_list = NULL; const char *path_basedir = libretro_info_dir; struct string_list *contents = string_list_new(); bool ok = dir_list_append(contents, path, exts, false, dir_show_hidden_files, false, false); #if defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP /* UWP: browse the optional packages for additional cores */ struct string_list *core_packages = string_list_new(); uwp_fill_installed_core_packages(core_packages); for (i = 0; i < core_packages->size; i++) { dir_list_append(contents, core_packages->elems[i].data, exts, false, dir_show_hidden_files, false, false); } string_list_free(core_packages); #else /* Keep the old 'directory not found' behavior */ if (!ok) { string_list_free(contents); contents = NULL; } #endif if (!contents) return NULL; core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list)); if (!core_info_list) goto error; core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info)); if (!core_info) goto error; core_info_list->list = core_info; core_info_list->count = contents->size; for (i = 0; i < contents->size; i++) { size_t info_path_size = PATH_MAX_LENGTH * sizeof(char); char *info_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); info_path[0] = '\0'; if ( core_info_list_iterate(info_path, info_path_size, path_basedir, contents, i) && path_is_valid(info_path)) { char *tmp = NULL; bool tmp_bool = false; unsigned count = 0; config_file_t *conf = config_file_new(info_path); free(info_path); if (!conf) continue; if (config_get_string(conf, "display_name", &tmp) && !string_is_empty(tmp)) { core_info[i].display_name = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "display_version", &tmp) && !string_is_empty(tmp)) { core_info[i].display_version = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "corename", &tmp) && !string_is_empty(tmp)) { core_info[i].core_name = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "systemname", &tmp) && !string_is_empty(tmp)) { core_info[i].systemname = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "systemid", &tmp) && !string_is_empty(tmp)) { core_info[i].system_id = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "manufacturer", &tmp) && !string_is_empty(tmp)) { core_info[i].system_manufacturer = strdup(tmp); free(tmp); tmp = NULL; } config_get_uint(conf, "firmware_count", &count); core_info[i].firmware_count = count; if (config_get_string(conf, "supported_extensions", &tmp) && !string_is_empty(tmp)) { core_info[i].supported_extensions = strdup(tmp); core_info[i].supported_extensions_list = string_split(core_info[i].supported_extensions, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "authors", &tmp) && !string_is_empty(tmp)) { core_info[i].authors = strdup(tmp); core_info[i].authors_list = string_split(core_info[i].authors, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "permissions", &tmp) && !string_is_empty(tmp)) { core_info[i].permissions = strdup(tmp); core_info[i].permissions_list = string_split(core_info[i].permissions, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "license", &tmp) && !string_is_empty(tmp)) { core_info[i].licenses = strdup(tmp); core_info[i].licenses_list = string_split(core_info[i].licenses, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "categories", &tmp) && !string_is_empty(tmp)) { core_info[i].categories = strdup(tmp); core_info[i].categories_list = string_split(core_info[i].categories, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "database", &tmp) && !string_is_empty(tmp)) { core_info[i].databases = strdup(tmp); core_info[i].databases_list = string_split(core_info[i].databases, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "notes", &tmp) && !string_is_empty(tmp)) { core_info[i].notes = strdup(tmp); core_info[i].note_list = string_split(core_info[i].notes, "|"); free(tmp); tmp = NULL; } if (tmp) free(tmp); tmp = NULL; if (config_get_bool(conf, "supports_no_game", &tmp_bool)) core_info[i].supports_no_game = tmp_bool; if (config_get_bool(conf, "database_match_archive_member", &tmp_bool)) core_info[i].database_match_archive_member = tmp_bool; core_info[i].config_data = conf; } else free(info_path); if (!string_is_empty(contents->elems[i].data)) core_info[i].path = strdup(contents->elems[i].data); if (!core_info[i].display_name) core_info[i].display_name = strdup(path_basename(core_info[i].path)); } if (core_info_list) { core_info_list_resolve_all_extensions(core_info_list); core_info_list_resolve_all_firmware(core_info_list); } string_list_free(contents); return core_info_list; error: if (contents) string_list_free(contents); core_info_list_free(core_info_list); return NULL; }
core_info_list_t *core_info_list_new(const char *modules_path) { size_t i; core_info_t *core_info = NULL; core_info_list_t *core_info_list = NULL; struct string_list *contents = (struct string_list*)dir_list_new(modules_path, EXT_EXECUTABLES, false); if (!contents) return NULL; core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list)); if (!core_info_list) goto error; core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info)); if (!core_info) goto error; core_info_list->list = core_info; core_info_list->count = contents->size; for (i = 0; i < contents->size; i++) { char info_path_base[PATH_MAX], info_path[PATH_MAX]; core_info[i].path = strdup(contents->elems[i].data); if (!core_info[i].path) break; fill_pathname_base(info_path_base, contents->elems[i].data, sizeof(info_path_base)); path_remove_extension(info_path_base); #if defined(RARCH_MOBILE) || defined(RARCH_CONSOLE) char *substr = strrchr(info_path_base, '_'); if (substr) *substr = '\0'; #endif strlcat(info_path_base, ".info", sizeof(info_path_base)); fill_pathname_join(info_path, (*g_settings.libretro_info_path) ? g_settings.libretro_info_path : modules_path, info_path_base, sizeof(info_path)); core_info[i].data = config_file_new(info_path); if (core_info[i].data) { unsigned count = 0; config_get_string(core_info[i].data, "display_name", &core_info[i].display_name); config_get_string(core_info[i].data, "systemname", &core_info[i].systemname); config_get_uint(core_info[i].data, "firmware_count", &count); core_info[i].firmware_count = count; if (config_get_string(core_info[i].data, "supported_extensions", &core_info[i].supported_extensions) && core_info[i].supported_extensions) core_info[i].supported_extensions_list = string_split(core_info[i].supported_extensions, "|"); if (config_get_string(core_info[i].data, "authors", &core_info[i].authors) && core_info[i].authors) core_info[i].authors_list = string_split(core_info[i].authors, "|"); if (config_get_string(core_info[i].data, "permissions", &core_info[i].permissions) && core_info[i].permissions) core_info[i].permissions_list = string_split(core_info[i].permissions, "|"); if (config_get_string(core_info[i].data, "notes", &core_info[i].notes) && core_info[i].notes) core_info[i].note_list = string_split(core_info[i].notes, "|"); } if (!core_info[i].display_name) core_info[i].display_name = strdup(path_basename(core_info[i].path)); } core_info_list_resolve_all_extensions(core_info_list); core_info_list_resolve_all_firmware(core_info_list); dir_list_free(contents); return core_info_list; error: if (contents) dir_list_free(contents); core_info_list_free(core_info_list); return NULL; }
core_info_list_t *core_info_list_new(void) { size_t i; core_info_t *core_info = NULL; core_info_list_t *core_info_list = NULL; settings_t *settings = config_get_ptr(); struct string_list *contents = dir_list_new_special(NULL, DIR_LIST_CORES); if (!contents) return NULL; core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list)); if (!core_info_list) goto error; core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info)); if (!core_info) goto error; core_info_list->list = core_info; core_info_list->count = contents->size; for (i = 0; i < contents->size; i++) { char info_path_base[PATH_MAX_LENGTH] = {0}; char info_path[PATH_MAX_LENGTH] = {0}; core_info[i].path = strdup(contents->elems[i].data); if (!core_info[i].path) break; fill_pathname_base(info_path_base, contents->elems[i].data, sizeof(info_path_base)); path_remove_extension(info_path_base); #if defined(RARCH_MOBILE) || (defined(RARCH_CONSOLE) && !defined(PSP)) char *substr = strrchr(info_path_base, '_'); if (substr) *substr = '\0'; #endif strlcat(info_path_base, ".info", sizeof(info_path_base)); fill_pathname_join(info_path, (*settings->libretro_info_path) ? settings->libretro_info_path : settings->libretro_directory, info_path_base, sizeof(info_path)); core_info[i].data = config_file_new(info_path); if (core_info[i].data) { unsigned count = 0; config_get_string(core_info[i].data, "display_name", &core_info[i].display_name); config_get_string(core_info[i].data, "corename", &core_info[i].core_name); config_get_string(core_info[i].data, "systemname", &core_info[i].systemname); config_get_string(core_info[i].data, "manufacturer", &core_info[i].system_manufacturer); config_get_uint(core_info[i].data, "firmware_count", &count); core_info[i].firmware_count = count; if (config_get_string(core_info[i].data, "supported_extensions", &core_info[i].supported_extensions) && core_info[i].supported_extensions) core_info[i].supported_extensions_list = string_split(core_info[i].supported_extensions, "|"); if (config_get_string(core_info[i].data, "authors", &core_info[i].authors) && core_info[i].authors) core_info[i].authors_list = string_split(core_info[i].authors, "|"); if (config_get_string(core_info[i].data, "permissions", &core_info[i].permissions) && core_info[i].permissions) core_info[i].permissions_list = string_split(core_info[i].permissions, "|"); if (config_get_string(core_info[i].data, "license", &core_info[i].licenses) && core_info[i].licenses) core_info[i].licenses_list = string_split(core_info[i].licenses, "|"); if (config_get_string(core_info[i].data, "categories", &core_info[i].categories) && core_info[i].categories) core_info[i].categories_list = string_split(core_info[i].categories, "|"); if (config_get_string(core_info[i].data, "database", &core_info[i].databases) && core_info[i].databases) core_info[i].databases_list = string_split(core_info[i].databases, "|"); if (config_get_string(core_info[i].data, "notes", &core_info[i].notes) && core_info[i].notes) core_info[i].note_list = string_split(core_info[i].notes, "|"); config_get_bool(core_info[i].data, "supports_no_game", &core_info[i].supports_no_game); } if (!core_info[i].display_name) core_info[i].display_name = strdup(path_basename(core_info[i].path)); } core_info_list_resolve_all_extensions(core_info_list); core_info_list_resolve_all_firmware(core_info_list); dir_list_free(contents); return core_info_list; error: if (contents) dir_list_free(contents); core_info_list_free(core_info_list); return NULL; }
static core_info_list_t *core_info_list_new(const char *path) { size_t i; core_info_t *core_info = NULL; core_info_list_t *core_info_list = NULL; struct string_list *contents = dir_list_new_special( path, DIR_LIST_CORES, NULL); settings_t *settings = config_get_ptr(); const char *path_basedir = !string_is_empty(settings->paths.path_libretro_info) ? settings->paths.path_libretro_info : settings->paths.directory_libretro; if (!contents) return NULL; core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list)); if (!core_info_list) goto error; core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info)); if (!core_info) goto error; core_info_list->list = core_info; core_info_list->count = contents->size; for (i = 0; i < contents->size; i++) { size_t info_path_size = PATH_MAX_LENGTH * sizeof(char); char *info_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); info_path[0] = '\0'; if ( core_info_list_iterate(info_path, info_path_size, path_basedir, contents, i) && path_is_valid(info_path)) { char *tmp = NULL; bool tmp_bool = false; unsigned count = 0; config_file_t *conf = config_file_new(info_path); free(info_path); if (!conf) continue; if (config_get_string(conf, "display_name", &tmp) && !string_is_empty(tmp)) { core_info[i].display_name = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "corename", &tmp) && !string_is_empty(tmp)) { core_info[i].core_name = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "systemname", &tmp) && !string_is_empty(tmp)) { core_info[i].systemname = strdup(tmp); free(tmp); tmp = NULL; } if (config_get_string(conf, "manufacturer", &tmp) && !string_is_empty(tmp)) { core_info[i].system_manufacturer = strdup(tmp); free(tmp); tmp = NULL; } config_get_uint(conf, "firmware_count", &count); core_info[i].firmware_count = count; if (config_get_string(conf, "supported_extensions", &tmp) && !string_is_empty(tmp)) { core_info[i].supported_extensions = strdup(tmp); core_info[i].supported_extensions_list = string_split(core_info[i].supported_extensions, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "authors", &tmp) && !string_is_empty(tmp)) { core_info[i].authors = strdup(tmp); core_info[i].authors_list = string_split(core_info[i].authors, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "permissions", &tmp) && !string_is_empty(tmp)) { core_info[i].permissions = strdup(tmp); core_info[i].permissions_list = string_split(core_info[i].permissions, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "license", &tmp) && !string_is_empty(tmp)) { core_info[i].licenses = strdup(tmp); core_info[i].licenses_list = string_split(core_info[i].licenses, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "categories", &tmp) && !string_is_empty(tmp)) { core_info[i].categories = strdup(tmp); core_info[i].categories_list = string_split(core_info[i].categories, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "database", &tmp) && !string_is_empty(tmp)) { core_info[i].databases = strdup(tmp); core_info[i].databases_list = string_split(core_info[i].databases, "|"); free(tmp); tmp = NULL; } if (config_get_string(conf, "notes", &tmp) && !string_is_empty(tmp)) { core_info[i].notes = strdup(tmp); core_info[i].note_list = string_split(core_info[i].notes, "|"); free(tmp); tmp = NULL; } if (tmp) free(tmp); tmp = NULL; if (config_get_bool(conf, "supports_no_game", &tmp_bool)) core_info[i].supports_no_game = tmp_bool; if (config_get_bool(conf, "database_match_archive_member", &tmp_bool)) core_info[i].database_match_archive_member = tmp_bool; core_info[i].config_data = conf; } else free(info_path); if (!string_is_empty(contents->elems[i].data)) core_info[i].path = strdup(contents->elems[i].data); if (!core_info[i].display_name) core_info[i].display_name = strdup(path_basename(core_info[i].path)); } if (core_info_list) { core_info_list_resolve_all_extensions(core_info_list); core_info_list_resolve_all_firmware(core_info_list); } dir_list_free(contents); return core_info_list; error: if (contents) dir_list_free(contents); core_info_list_free(core_info_list); return NULL; }
static bool shader_parse_imports(config_file_t *conf, struct gfx_shader *shader) { char imports[1024]; char *save = NULL; const char *id; if (!config_get_array(conf, "imports", imports, sizeof(imports))) return true; for (id = strtok_r(imports, ";", &save); id && shader->variables < GFX_MAX_VARIABLES; shader->variables++, id = strtok_r(NULL, ";", &save)) { struct state_tracker_uniform_info *var = (struct state_tracker_uniform_info*) &shader->variable[shader->variables]; strlcpy(var->id, id, sizeof(var->id)); char semantic_buf[64]; char wram_buf[64]; char input_slot_buf[64]; char mask_buf[64]; char equal_buf[64]; print_buf(semantic_buf, "%s_semantic", id); print_buf(wram_buf, "%s_wram", id); print_buf(input_slot_buf, "%s_input_slot", id); print_buf(mask_buf, "%s_mask", id); print_buf(equal_buf, "%s_equal", id); char semantic[64]; if (!config_get_array(conf, semantic_buf, semantic, sizeof(semantic))) { RARCH_ERR("No semantic for import variable.\n"); return false; } if (strcmp(semantic, "capture") == 0) var->type = RARCH_STATE_CAPTURE; else if (strcmp(semantic, "transition") == 0) var->type = RARCH_STATE_TRANSITION; else if (strcmp(semantic, "transition_count") == 0) var->type = RARCH_STATE_TRANSITION_COUNT; else if (strcmp(semantic, "capture_previous") == 0) var->type = RARCH_STATE_CAPTURE_PREV; else if (strcmp(semantic, "transition_previous") == 0) var->type = RARCH_STATE_TRANSITION_PREV; else if (strcmp(semantic, "python") == 0) var->type = RARCH_STATE_PYTHON; else { RARCH_ERR("Invalid semantic.\n"); return false; } unsigned addr = 0, mask = 0, equal = 0; if (var->type != RARCH_STATE_PYTHON) { unsigned input_slot = 0; if (config_get_uint(conf, input_slot_buf, &input_slot)) { switch (input_slot) { case 1: var->ram_type = RARCH_STATE_INPUT_SLOT1; break; case 2: var->ram_type = RARCH_STATE_INPUT_SLOT2; break; default: RARCH_ERR("Invalid input slot for import.\n"); return false; } } else if (config_get_hex(conf, wram_buf, &addr)) { var->ram_type = RARCH_STATE_WRAM; var->addr = addr; } else { RARCH_ERR("No address assigned to semantic.\n"); return false; } } if (config_get_hex(conf, mask_buf, &mask)) var->mask = mask; if (config_get_hex(conf, equal_buf, &equal)) var->equal = equal; } config_get_path(conf, "import_script", shader->script_path, sizeof(shader->script_path)); config_get_array(conf, "import_script_class", shader->script_class, sizeof(shader->script_class)); return true; }
static bool input_overlay_load_overlay(input_overlay_t *ol, config_file_t *conf, const char *config_path, struct overlay *overlay, unsigned index) { size_t i; char overlay_path_key[64]; char overlay_name_key[64]; char overlay_path[PATH_MAX]; char overlay_resolved_path[PATH_MAX]; snprintf(overlay_path_key, sizeof(overlay_path_key), "overlay%u_overlay", index); if (config_get_path(conf, overlay_path_key, overlay_path, sizeof(overlay_path))) { struct texture_image img = {0}; fill_pathname_resolve_relative(overlay_resolved_path, config_path, overlay_path, sizeof(overlay_resolved_path)); if (texture_image_load(&img, overlay_resolved_path)) overlay->image = img; else { RARCH_ERR("[Overlay]: Failed to load image: %s.\n", overlay_resolved_path); return false; } } snprintf(overlay_name_key, sizeof(overlay_name_key), "overlay%u_name", index); config_get_array(conf, overlay_name_key, overlay->name, sizeof(overlay->name)); // By default, we stretch the overlay out in full. overlay->x = overlay->y = 0.0f; overlay->w = overlay->h = 1.0f; char overlay_rect_key[64]; snprintf(overlay_rect_key, sizeof(overlay_rect_key), "overlay%u_rect", index); char overlay_rect[256]; if (config_get_array(conf, overlay_rect_key, overlay_rect, sizeof(overlay_rect))) { struct string_list *list = string_split(overlay_rect, ", "); if (list->size < 4) { RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay_rect); return false; } overlay->x = (float)strtod(list->elems[0].data, NULL); overlay->y = (float)strtod(list->elems[1].data, NULL); overlay->w = (float)strtod(list->elems[2].data, NULL); overlay->h = (float)strtod(list->elems[3].data, NULL); string_list_free(list); } char overlay_full_screen_key[64]; snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key), "overlay%u_full_screen", index); overlay->full_screen = false; config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen); char overlay_descs_key[64]; snprintf(overlay_descs_key, sizeof(overlay_descs_key), "overlay%u_descs", index); unsigned descs = 0; if (!config_get_uint(conf, overlay_descs_key, &descs)) { RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay_descs_key); return false; } overlay->descs = (struct overlay_desc*)calloc(descs, sizeof(*overlay->descs)); if (!overlay->descs) { RARCH_ERR("[Overlay]: Failed to allocate descs.\n"); return false; } overlay->size = descs; char conf_key[64]; bool normalized = false; snprintf(conf_key, sizeof(conf_key), "overlay%u_normalized", index); config_get_bool(conf, conf_key, &normalized); float alpha_mod = 1.0f; snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", index); config_get_float(conf, conf_key, &alpha_mod); float range_mod = 1.0f; snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", index); config_get_float(conf, conf_key, &range_mod); for (i = 0; i < overlay->size; i++) { if (!input_overlay_load_desc(ol, conf, &overlay->descs[i], index, i, overlay->image.width, overlay->image.height, normalized, alpha_mod, range_mod)) { RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n", (unsigned)i); return false; } } // Precache load image array for simplicity. overlay->load_images = (struct texture_image*)calloc(1 + overlay->size, sizeof(struct texture_image)); if (!overlay->load_images) { RARCH_ERR("[Overlay]: Failed to allocate load_images.\n"); return false; } if (overlay->image.pixels) overlay->load_images[overlay->load_images_size++] = overlay->image; for (i = 0; i < overlay->size; i++) { if (overlay->descs[i].image.pixels) { overlay->descs[i].image_index = overlay->load_images_size; overlay->load_images[overlay->load_images_size++] = overlay->descs[i].image; } } // Assume for now that scaling center is in the middle. // TODO: Make this configurable. overlay->block_scale = false; overlay->center_x = overlay->x + 0.5f * overlay->w; overlay->center_y = overlay->y + 0.5f * overlay->h; return true; }
static bool input_overlay_load_overlay(config_file_t *conf, const char *config_path, struct overlay *overlay, unsigned index) { char overlay_path_key[64]; char overlay_name_key[64]; char overlay_path[PATH_MAX]; char overlay_resolved_path[PATH_MAX]; snprintf(overlay_path_key, sizeof(overlay_path_key), "overlay%u_overlay", index); if (!config_get_path(conf, overlay_path_key, overlay_path, sizeof(overlay_path))) { RARCH_ERR("[Overlay]: Config key: %s is not set.\n", overlay_path_key); return false; } snprintf(overlay_name_key, sizeof(overlay_name_key), "overlay%u_name", index); config_get_array(conf, overlay_name_key, overlay->name, sizeof(overlay->name)); fill_pathname_resolve_relative(overlay_resolved_path, config_path, overlay_path, sizeof(overlay_resolved_path)); struct texture_image img = {0}; if (!texture_image_load(overlay_resolved_path, &img)) { RARCH_ERR("Failed to load image: %s.\n", overlay_path); return false; } overlay->image = img.pixels; overlay->width = img.width; overlay->height = img.height; // By default, we stretch the overlay out in full. overlay->x = overlay->y = 0.0f; overlay->w = overlay->h = 1.0f; char overlay_rect_key[64]; snprintf(overlay_rect_key, sizeof(overlay_rect_key), "overlay%u_rect", index); char overlay_rect[256]; if (config_get_array(conf, overlay_rect_key, overlay_rect, sizeof(overlay_rect))) { struct string_list *list = string_split(overlay_rect, ", "); if (list->size < 4) { RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay_rect); return false; } overlay->x = strtod(list->elems[0].data, NULL); overlay->y = strtod(list->elems[1].data, NULL); overlay->w = strtod(list->elems[2].data, NULL); overlay->h = strtod(list->elems[3].data, NULL); string_list_free(list); } char overlay_full_screen_key[64]; snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key), "overlay%u_full_screen", index); overlay->full_screen = false; config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen); char overlay_descs_key[64]; snprintf(overlay_descs_key, sizeof(overlay_descs_key), "overlay%u_descs", index); unsigned descs = 0; if (!config_get_uint(conf, overlay_descs_key, &descs)) { RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay_descs_key); return false; } overlay->descs = (struct overlay_desc*)calloc(descs, sizeof(*overlay->descs)); if (!overlay->descs) { RARCH_ERR("[Overlay]: Failed to allocate descs.\n"); return false; } overlay->size = descs; for (size_t i = 0; i < overlay->size; i++) { if (!input_overlay_load_desc(conf, &overlay->descs[i], index, i, img.width, img.height)) { RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n", (unsigned)i); return false; } } // Assume for now that scaling center is in the middle. // TODO: Make this configurable. overlay->block_scale = false; overlay->center_x = overlay->x + 0.5f * overlay->w; overlay->center_y = overlay->y + 0.5f * overlay->h; return true; }
static core_info_list_t *core_info_list_new(void) { size_t i; core_info_t *core_info = NULL; core_info_list_t *core_info_list = NULL; struct string_list *contents = NULL; settings_t *settings = config_get_ptr(); if (!settings) return NULL; contents = dir_list_new_special( settings->directory.libretro, DIR_LIST_CORES, NULL); if (!contents) return NULL; core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list)); if (!core_info_list) goto error; core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info)); if (!core_info) goto error; core_info_list->list = core_info; core_info_list->count = contents->size; for (i = 0; i < contents->size; i++) { config_file_t *conf = core_info_list_iterate(contents, i); if (conf) { bool tmp_bool = false; unsigned count = 0; config_get_string(conf, "display_name", &core_info[i].display_name); config_get_string(conf, "corename", &core_info[i].core_name); config_get_string(conf, "systemname", &core_info[i].systemname); config_get_string(conf, "manufacturer", &core_info[i].system_manufacturer); config_get_uint(conf, "firmware_count", &count); core_info[i].firmware_count = count; if (config_get_string(conf, "supported_extensions", &core_info[i].supported_extensions) && core_info[i].supported_extensions) core_info[i].supported_extensions_list = string_split(core_info[i].supported_extensions, "|"); if (config_get_string(conf, "authors", &core_info[i].authors) && core_info[i].authors) core_info[i].authors_list = string_split(core_info[i].authors, "|"); if (config_get_string(conf, "permissions", &core_info[i].permissions) && core_info[i].permissions) core_info[i].permissions_list = string_split(core_info[i].permissions, "|"); if (config_get_string(conf, "license", &core_info[i].licenses) && core_info[i].licenses) core_info[i].licenses_list = string_split(core_info[i].licenses, "|"); if (config_get_string(conf, "categories", &core_info[i].categories) && core_info[i].categories) core_info[i].categories_list = string_split(core_info[i].categories, "|"); if (config_get_string(conf, "database", &core_info[i].databases) && core_info[i].databases) core_info[i].databases_list = string_split(core_info[i].databases, "|"); if (config_get_string(conf, "notes", &core_info[i].notes) && core_info[i].notes) core_info[i].note_list = string_split(core_info[i].notes, "|"); if (config_get_bool(conf, "supports_no_game", &tmp_bool)) core_info[i].supports_no_game = tmp_bool; core_info[i].config_data = conf; } core_info[i].path = strdup(contents->elems[i].data); if (!core_info[i].display_name) core_info[i].display_name = strdup(path_basename(core_info[i].path)); } core_info_list_resolve_all_extensions(core_info_list); core_info_list_resolve_all_firmware(core_info_list); dir_list_free(contents); return core_info_list; error: if (contents) dir_list_free(contents); core_info_list_free(core_info_list); return NULL; }
/** * video_shader_read_conf_cgp: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Loads preset file and all associated state (passes, * textures, imports, etc). * * Returns: true (1) if successful, otherwise false (0). **/ bool video_shader_read_conf_cgp(config_file_t *conf, struct video_shader *shader) { unsigned i; union string_list_elem_attr attr; unsigned shaders = 0; settings_t *settings = config_get_ptr(); struct string_list *file_list = NULL; (void)file_list; memset(shader, 0, sizeof(*shader)); shader->type = RARCH_SHADER_CG; if (!config_get_uint(conf, "shaders", &shaders)) { RARCH_ERR("Cannot find \"shaders\" param.\n"); return false; } if (!shaders) { RARCH_ERR("Need to define at least 1 shader.\n"); return false; } if (!config_get_int(conf, "feedback_pass", &shader->feedback_pass)) shader->feedback_pass = -1; shader->passes = MIN(shaders, GFX_MAX_SHADERS); attr.i = 0; strlcpy(shader->path, conf->path, sizeof(shader->path)); if (settings->bools.video_shader_watch_files) { if (file_change_data) frontend_driver_watch_path_for_changes(NULL, 0, &file_change_data); file_change_data = NULL; file_list = string_list_new(); string_list_append(file_list, conf->path, attr); } for (i = 0; i < shader->passes; i++) { if (!video_shader_parse_pass(conf, &shader->pass[i], i)) { if (file_list) { string_list_free(file_list); file_list = NULL; } return false; } if (settings->bools.video_shader_watch_files && file_list) string_list_append(file_list, shader->pass[i].source.path, attr); } if (settings->bools.video_shader_watch_files) { int flags = PATH_CHANGE_TYPE_MODIFIED | PATH_CHANGE_TYPE_WRITE_FILE_CLOSED | PATH_CHANGE_TYPE_FILE_MOVED | PATH_CHANGE_TYPE_FILE_DELETED; frontend_driver_watch_path_for_changes(file_list, flags, &file_change_data); if (file_list) string_list_free(file_list); } command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL); if (!video_shader_parse_textures(conf, shader)) return false; if (!video_shader_parse_imports(conf, shader)) return false; return true; }
/** * video_shader_parse_imports: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Resolves import parameters belonging to shaders. * * Returns: true (1) if successful, otherwise false (0). **/ static bool video_shader_parse_imports(config_file_t *conf, struct video_shader *shader) { size_t path_size = PATH_MAX_LENGTH * sizeof(char); const char *id = NULL; char *save = NULL; char *tmp_str = NULL; char *imports = (char*)malloc(1024 * sizeof(char)); imports[0] = '\0'; if (!config_get_array(conf, "imports", imports, 1024 * sizeof(char))) { free(imports); return true; } for (id = strtok_r(imports, ";", &save); id && shader->variables < GFX_MAX_VARIABLES; shader->variables++, id = strtok_r(NULL, ";", &save)) { char semantic_buf[64]; char wram_buf[64]; char input_slot_buf[64]; char mask_buf[64]; char equal_buf[64]; char semantic[64]; unsigned addr = 0; unsigned mask = 0; unsigned equal = 0; struct state_tracker_uniform_info *var = &shader->variable[shader->variables]; semantic_buf[0] = wram_buf[0] = input_slot_buf[0] = mask_buf[0] = equal_buf[0] = semantic[0] = '\0'; strlcpy(var->id, id, sizeof(var->id)); snprintf(semantic_buf, sizeof(semantic_buf), "%s_semantic", id); if (!config_get_array(conf, semantic_buf, semantic, sizeof(semantic))) { RARCH_ERR("No semantic for import variable.\n"); goto error; } snprintf(wram_buf, sizeof(wram_buf), "%s_wram", id); snprintf(input_slot_buf, sizeof(input_slot_buf), "%s_input_slot", id); snprintf(mask_buf, sizeof(mask_buf), "%s_mask", id); snprintf(equal_buf, sizeof(equal_buf), "%s_equal", id); if (string_is_equal(semantic, "capture")) var->type = RARCH_STATE_CAPTURE; else if (string_is_equal(semantic, "transition")) var->type = RARCH_STATE_TRANSITION; else if (string_is_equal(semantic, "transition_count")) var->type = RARCH_STATE_TRANSITION_COUNT; else if (string_is_equal(semantic, "capture_previous")) var->type = RARCH_STATE_CAPTURE_PREV; else if (string_is_equal(semantic, "transition_previous")) var->type = RARCH_STATE_TRANSITION_PREV; else if (string_is_equal(semantic, "python")) var->type = RARCH_STATE_PYTHON; else { RARCH_ERR("Invalid semantic.\n"); goto error; } if (var->type != RARCH_STATE_PYTHON) { unsigned input_slot = 0; if (config_get_uint(conf, input_slot_buf, &input_slot)) { switch (input_slot) { case 1: var->ram_type = RARCH_STATE_INPUT_SLOT1; break; case 2: var->ram_type = RARCH_STATE_INPUT_SLOT2; break; default: RARCH_ERR("Invalid input slot for import.\n"); goto error; } } else if (config_get_hex(conf, wram_buf, &addr)) { var->ram_type = RARCH_STATE_WRAM; var->addr = addr; } else { RARCH_ERR("No address assigned to semantic.\n"); goto error; } } if (config_get_hex(conf, mask_buf, &mask)) var->mask = mask; if (config_get_hex(conf, equal_buf, &equal)) var->equal = equal; } tmp_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); tmp_str[0] = '\0'; if (config_get_path(conf, "import_script", tmp_str, path_size)) strlcpy(shader->script_path, tmp_str, sizeof(shader->script_path)); config_get_array(conf, "import_script_class", shader->script_class, sizeof(shader->script_class)); free(tmp_str); free(imports); return true; error: free(imports); return false; }
bool input_overlay_load_overlays(input_overlay_t *ol) { unsigned i; config_file_t *conf = NULL; if (!ol) return false; conf = config_file_new(ol->overlay_path); if (!conf) { RARCH_ERR("Failed to load config file: %s.\n", ol->overlay_path); return false; } if (!config_get_uint(conf, "overlays", &ol->config.overlays.size)) { RARCH_ERR("overlays variable not defined in config.\n"); goto error; } if (!ol->config.overlays.size) goto error; ol->overlays = (struct overlay*)calloc( ol->config.overlays.size, sizeof(*ol->overlays)); if (!ol->overlays) goto error; ol->size = ol->config.overlays.size; ol->pos = 0; ol->resolve_pos = 0; for (i = 0; i < ol->size; i++) { char conf_key[64]; char overlay_full_screen_key[64]; struct overlay *overlay = &ol->overlays[i]; if (!overlay) continue; snprintf(overlay->config.descs.key, sizeof(overlay->config.descs.key), "overlay%u_descs", i); if (!config_get_uint(conf, overlay->config.descs.key, &overlay->config.descs.size)) { RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay->config.descs.key); goto error; } overlay->descs = (struct overlay_desc*) calloc(overlay->config.descs.size, sizeof(*overlay->descs)); if (!overlay->descs) { RARCH_ERR("[Overlay]: Failed to allocate descs.\n"); goto error; } overlay->size = overlay->config.descs.size; snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key), "overlay%u_full_screen", i); overlay->full_screen = false; config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen); overlay->config.normalized = false; overlay->config.alpha_mod = 1.0f; overlay->config.range_mod = 1.0f; snprintf(conf_key, sizeof(conf_key), "overlay%u_normalized", i); config_get_bool(conf, conf_key, &overlay->config.normalized); snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", i); config_get_float(conf, conf_key, &overlay->config.alpha_mod); snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", i); config_get_float(conf, conf_key, &overlay->config.range_mod); /* Precache load image array for simplicity. */ overlay->load_images = (struct texture_image*) calloc(1 + overlay->size, sizeof(struct texture_image)); if (!overlay->load_images) { RARCH_ERR("[Overlay]: Failed to allocate load_images.\n"); goto error; } snprintf(overlay->config.paths.key, sizeof(overlay->config.paths.key), "overlay%u_overlay", i); config_get_path(conf, overlay->config.paths.key, overlay->config.paths.path, sizeof(overlay->config.paths.path)); if (overlay->config.paths.path[0] != '\0') { char overlay_resolved_path[PATH_MAX_LENGTH]; struct texture_image img = {0}; fill_pathname_resolve_relative(overlay_resolved_path, ol->overlay_path, overlay->config.paths.path, sizeof(overlay_resolved_path)); if (!texture_image_load(&img, overlay_resolved_path)) { RARCH_ERR("[Overlay]: Failed to load image: %s.\n", overlay_resolved_path); ol->loading_status = OVERLAY_IMAGE_TRANSFER_ERROR; goto error; } overlay->image = img; } snprintf(overlay->config.names.key, sizeof(overlay->config.names.key), "overlay%u_name", i); config_get_array(conf, overlay->config.names.key, overlay->name, sizeof(overlay->name)); /* By default, we stretch the overlay out in full. */ overlay->x = overlay->y = 0.0f; overlay->w = overlay->h = 1.0f; snprintf(overlay->config.rect.key, sizeof(overlay->config.rect.key), "overlay%u_rect", i); if (config_get_array(conf, overlay->config.rect.key, overlay->config.rect.array, sizeof(overlay->config.rect.array))) { struct string_list *list = string_split(overlay->config.rect.array, ", "); if (!list || list->size < 4) { RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay->config.rect.array); string_list_free(list); goto error; } overlay->x = (float)strtod(list->elems[0].data, NULL); overlay->y = (float)strtod(list->elems[1].data, NULL); overlay->w = (float)strtod(list->elems[2].data, NULL); overlay->h = (float)strtod(list->elems[3].data, NULL); string_list_free(list); } /* Assume for now that scaling center is in the middle. * TODO: Make this configurable. */ overlay->block_scale = false; overlay->center_x = overlay->x + 0.5f * overlay->w; overlay->center_y = overlay->y + 0.5f * overlay->h; } ol->state = OVERLAY_STATUS_DEFERRED_LOADING; config_file_free(conf); return true; error: config_file_free(conf); ol->state = OVERLAY_STATUS_DEFERRED_ERROR; return false; }